﻿/* SCRIPT INSPECTOR 3
 * version 3.0.30, May 2021
 * Copyright © 2012-2021, Flipbook Games
 * 
 * Unity's legendary editor for C#, UnityScript, Boo, Shaders, and text,
 * now transformed into an advanced C# IDE!!!
 * 
 * Follow me on http://twitter.com/FlipbookGames
 * Like Flipbook Games on Facebook http://facebook.com/FlipbookGames
 * Join discussion in Unity forums http://forum.unity3d.com/threads/138329
 * Contact info@flipbookgames.com for feedback, bug reports, or suggestions.
 * Visit http://flipbookgames.com/ for more info.
 */

namespace ScriptInspector
{

using System.Collections.Generic;

public static class UnitySymbols
{
//
// Taken from the Search index of Unity script documentation (index.js)
//
public static readonly Dictionary<string, string> summaries = new Dictionary<string, string> {
#if !UNITY_WEBPLAYER
{ "AccelerationEvent", "Structure describing acceleration status of the device." },
{ "AccelerationEvent-acceleration", "Value of acceleration." },
{ "AccelerationEvent-deltaTime", "Amount of time passed since last accelerometer measurement." },
{ "ADBannerView", "ADBannerView is a wrapper around the ADBannerView class found in the Apple iAd framework and is only available on iOS." },
{ "ADBannerView-ctor", "Creates a banner view with given type and auto-layout params." },
{ "ADBannerView-layout", "Banner layout." },
{ "ADBannerView-loaded", "Checks if banner contents are loaded." },
{ "ADBannerView-position", "The position of the banner view." },
{ "ADBannerView-size", "The size of the banner view." },
{ "ADBannerView-visible", "Banner visibility. Initially banner is not visible." },
{ "ADBannerView.BannerWasClickedDelegate", "Will be fired when banner was clicked." },
{ "ADBannerView.BannerWasLoadedDelegate", "Will be fired when banner loaded new ad." },
{ "ADBannerView.IsAvailable", "Checks if the banner type is available (e.g. MediumRect is available only starting with ios6)." },
{ "ADBannerView.Layout", "Specifies how banner should be layed out on screen." },
{ "ADBannerView.Layout.Bottom", "Traditional Banner: align to screen bottom." },
{ "ADBannerView.Layout.BottomCenter", "Rect Banner: align to screen bottom, placing at the center." },
{ "ADBannerView.Layout.BottomLeft", "Rect Banner: place in bottom-left corner." },
{ "ADBannerView.Layout.BottomRight", "Rect Banner: place in bottom-right corner." },
{ "ADBannerView.Layout.Center", "Rect Banner: place exactly at screen center." },
{ "ADBannerView.Layout.CenterLeft", "Rect Banner: align to screen left, placing at the center." },
{ "ADBannerView.Layout.CenterRight", "Rect Banner: align to screen right, placing at the center." },
{ "ADBannerView.Layout.Manual", "Completely manual positioning." },
{ "ADBannerView.Layout.Top", "Traditional Banner: align to screen top." },
{ "ADBannerView.Layout.TopCenter", "Rect Banner: align to screen top, placing at the center." },
{ "ADBannerView.Layout.TopLeft", "Rect Banner: place in top-left corner." },
{ "ADBannerView.Layout.TopRight", "Rect Banner: place in top-right corner." },
{ "ADBannerView.Type", "The type of the banner view." },
{ "ADBannerView.Type.Banner", "Traditional Banner (it takes full screen width)." },
{ "ADBannerView.Type.MediumRect", "Rect Banner (300x250)." },
{ "AddComponentMenu", "The AddComponentMenu attribute allows you to place a script anywhere in the \"Component\" menu, instead of just the \"Component->Scripts\" menu." },
{ "AddComponentMenu-componentOrder", "The order of the component in the component menu (lower is higher to the top)." },
{ "AddComponentMenu-ctor", "The script will be placed in the component menu according to menuName." },
{ "ADInterstitialAd", "ADInterstitialAd is a wrapper around the ADInterstitialAd class found in the Apple iAd framework and is only available on iPad." },
{ "ADInterstitialAd-ctor", "Creates an interstitial ad." },
{ "ADInterstitialAd-isAvailable", "Checks if InterstitialAd is available (it is iPad-only and was added in iOS 4.3)." },
{ "ADInterstitialAd-loaded", "Has the interstitial ad object downloaded an advertisement? (Read Only)" },
{ "ADInterstitialAd.InterstitialWasLoadedDelegate", "Will be called when ad is ready to be shown." },
{ "ADInterstitialAd.ReloadAd", "Reload advertisement." },
{ "ADInterstitialAd.Show", "Shows full-screen advertisement to user." },
{ "AnchoredJoint2D", "Parent class for all joints that have anchor points." },
{ "AnchoredJoint2D-anchor", "The joint's anchor point on the object that has the joint component." },
{ "AnchoredJoint2D-connectedAnchor", "The joint's anchor point on the second object (ie, the one which doesn't have the joint component)." },
{ "AndroidActivityIndicatorStyle", "ActivityIndicator Style (Android Specific)." },
{ "AndroidActivityIndicatorStyle.DontShow", "Do not show ActivityIndicator." },
{ "AndroidActivityIndicatorStyle.InversedLarge", "Large Inversed (android.R.attr.progressBarStyleLargeInverse)." },
{ "AndroidActivityIndicatorStyle.InversedSmall", "Small Inversed (android.R.attr.progressBarStyleSmallInverse)." },
{ "AndroidActivityIndicatorStyle.Large", "Large (android.R.attr.progressBarStyleLarge)." },
{ "AndroidActivityIndicatorStyle.Small", "Small (android.R.attr.progressBarStyleSmall)." },
{ "AndroidBuildSubtarget", "Target Android build platform." },
{ "AndroidBuildSubtarget.ATC", "ATI texture compression. Available on devices running Adreno GPU, including HTC Nexus One, Droid Incredible, EVO, and others." },
{ "AndroidBuildSubtarget.DXT", "S3 texture compression, nonspecific to DXT variant. Supported on devices running Nvidia Tegra2 platform, including Motorala Xoom, Motorola Atrix, Droid Bionic, and others." },
{ "AndroidBuildSubtarget.ETC", "ETC1 texture compression (or RGBA16 for textures with alpha), supported by all devices." },
{ "AndroidBuildSubtarget.Generic", "Don't override texture compression." },
{ "AndroidBuildSubtarget.PVRTC", "PowerVR texture compression. Available in devices running PowerVR SGX530/540 GPU, such as Motorola DROID series; Samsung Galaxy S, Nexus S, and Galaxy Tab; and others." },
{ "AndroidInput", "AndroidInput provides support for off-screen touch input, such as a touchpad." },
{ "AndroidInput-secondaryTouchEnabled", "Property indicating whether the system provides secondary touch input." },
{ "AndroidInput-secondaryTouchHeight", "Property indicating the height of the secondary touchpad." },
{ "AndroidInput-secondaryTouchWidth", "Property indicating the width of the secondary touchpad." },
{ "AndroidInput-touchCountSecondary", "Number of secondary touches. Guaranteed not to change throughout the frame. (Read Only)." },
{ "AndroidInput.GetSecondaryTouch", "Returns object representing status of a specific touch on a secondary touchpad (Does not allocate temporary variables)." },
{ "AndroidJavaClass", "AndroidJavaClass is the Unity representation of a generic instance of java.lang.Class." },
{ "AndroidJavaClass-ctor", "Construct an AndroidJavaClass from the class name." },
{ "AndroidJavaObject", "AndroidJavaObject is the Unity representation of a generic instance of java.lang.Object." },
{ "AndroidJavaObject-ctor", "Construct an AndroidJavaObject based on the name of the class." },
{ "AndroidJavaObject.Call", "Calls a Java method on an object (non-static)." },
{ "AndroidJavaObject.CallStatic", "Call a static Java method on a class." },
{ "AndroidJavaObject.Dispose", "IDisposable callback." },
{ "AndroidJavaObject.Get", "Get the value of a field in an object (non-static)." },
{ "AndroidJavaObject.GetRawClass", "Retrieve the raw jclass pointer to the Java class." },
{ "AndroidJavaObject.GetRawObject", "Retrieve the raw jobject pointer to the Java object." },
{ "AndroidJavaObject.GetStatic", "Get the value of a static field in an object type." },
{ "AndroidJavaObject.Set", "Set the value of a field in an object (non-static)." },
{ "AndroidJavaObject.SetStatic", "Set the value of a static field in an object type." },
{ "AndroidJavaProxy", "This class can be used to implement any java interface. Any java vm method invocation matching the interface on the proxy object will automatically be passed to the c# implementation." },
{ "AndroidJavaProxy-ctor", "" },
{ "AndroidJavaProxy-javaInterface", "Java interface implemented by the proxy." },
{ "AndroidJavaProxy.Invoke", "Called by the java vm whenever a method is invoked on the java proxy interface. You can override this to run special code on method invokation, or you can leave the implementation as is, and leave the default behavior which is to look for c# methods matching the signature of the java method." },
{ "AndroidJavaRunnable", "AndroidJavaRunnable is the Unity representation of a java.lang.Runnable object." },
{ "AndroidJNI", "'Raw' JNI interface to Android Dalvik (Java) VM from Mono (CS/JS)." },
{ "AndroidJNI.AllocObject", "Allocates a new Java object without invoking any of the constructors for the object." },
{ "AndroidJNI.AttachCurrentThread", "Attaches the current thread to a Java (Dalvik) VM." },
{ "AndroidJNI.CallBooleanMethod", "Calls an instance (nonstatic) Java method defined by methodID, optionally passing an array of arguments (args) to the method." },
{ "AndroidJNI.CallByteMethod", "Calls an instance (nonstatic) Java method defined by methodID, optionally passing an array of arguments (args) to the method." },
{ "AndroidJNI.CallCharMethod", "Calls an instance (nonstatic) Java method defined by methodID, optionally passing an array of arguments (args) to the method." },
{ "AndroidJNI.CallDoubleMethod", "Calls an instance (nonstatic) Java method defined by methodID, optionally passing an array of arguments (args) to the method." },
{ "AndroidJNI.CallFloatMethod", "Calls an instance (nonstatic) Java method defined by methodID, optionally passing an array of arguments (args) to the method." },
{ "AndroidJNI.CallIntMethod", "Calls an instance (nonstatic) Java method defined by methodID, optionally passing an array of arguments (args) to the method." },
{ "AndroidJNI.CallLongMethod", "Calls an instance (nonstatic) Java method defined by methodID, optionally passing an array of arguments (args) to the method." },
{ "AndroidJNI.CallObjectMethod", "Calls an instance (nonstatic) Java method defined by methodID, optionally passing an array of arguments (args) to the method." },
{ "AndroidJNI.CallShortMethod", "Calls an instance (nonstatic) Java method defined by methodID, optionally passing an array of arguments (args) to the method." },
{ "AndroidJNI.CallStaticBooleanMethod", "Invokes a static method on a Java object, according to the specified methodID, optionally passing an array of arguments (args) to the method." },
{ "AndroidJNI.CallStaticByteMethod", "Invokes a static method on a Java object, according to the specified methodID, optionally passing an array of arguments (args) to the method." },
{ "AndroidJNI.CallStaticCharMethod", "Invokes a static method on a Java object, according to the specified methodID, optionally passing an array of arguments (args) to the method." },
{ "AndroidJNI.CallStaticDoubleMethod", "Invokes a static method on a Java object, according to the specified methodID, optionally passing an array of arguments (args) to the method." },
{ "AndroidJNI.CallStaticFloatMethod", "Invokes a static method on a Java object, according to the specified methodID, optionally passing an array of arguments (args) to the method." },
{ "AndroidJNI.CallStaticIntMethod", "Invokes a static method on a Java object, according to the specified methodID, optionally passing an array of arguments (args) to the method." },
{ "AndroidJNI.CallStaticLongMethod", "Invokes a static method on a Java object, according to the specified methodID, optionally passing an array of arguments (args) to the method." },
{ "AndroidJNI.CallStaticObjectMethod", "Invokes a static method on a Java object, according to the specified methodID, optionally passing an array of arguments (args) to the method." },
{ "AndroidJNI.CallStaticShortMethod", "Invokes a static method on a Java object, according to the specified methodID, optionally passing an array of arguments (args) to the method." },
{ "AndroidJNI.CallStaticStringMethod", "Invokes a static method on a Java object, according to the specified methodID, optionally passing an array of arguments (args) to the method." },
{ "AndroidJNI.CallStaticVoidMethod", "Invokes a static method on a Java object, according to the specified methodID, optionally passing an array of arguments (args) to the method." },
{ "AndroidJNI.CallStringMethod", "Calls an instance (nonstatic) Java method defined by methodID, optionally passing an array of arguments (args) to the method." },
{ "AndroidJNI.CallVoidMethod", "Calls an instance (nonstatic) Java method defined by methodID, optionally passing an array of arguments (args) to the method." },
{ "AndroidJNI.DeleteGlobalRef", "Deletes the global reference pointed to by obj." },
{ "AndroidJNI.DeleteLocalRef", "Deletes the local reference pointed to by obj." },
{ "AndroidJNI.DetachCurrentThread", "Detaches the current thread from a Java (Dalvik) VM." },
{ "AndroidJNI.EnsureLocalCapacity", "Ensures that at least a given number of local references can be created in the current thread." },
{ "AndroidJNI.ExceptionClear", "Clears any exception that is currently being thrown." },
{ "AndroidJNI.ExceptionDescribe", "Prints an exception and a backtrace of the stack to the logcat" },
{ "AndroidJNI.ExceptionOccurred", "Determines if an exception is being thrown." },
{ "AndroidJNI.FatalError", "Raises a fatal error and does not expect the VM to recover. This function does not return." },
{ "AndroidJNI.FindClass", "This function loads a locally-defined class." },
{ "AndroidJNI.FromBooleanArray", "Convert a Java array of boolean to a managed array of System.Boolean." },
{ "AndroidJNI.FromByteArray", "Convert a Java array of byte to a managed array of System.Byte." },
{ "AndroidJNI.FromCharArray", "Convert a Java array of char to a managed array of System.Char." },
{ "AndroidJNI.FromDoubleArray", "Convert a Java array of double to a managed array of System.Double." },
{ "AndroidJNI.FromFloatArray", "Convert a Java array of float to a managed array of System.Single." },
{ "AndroidJNI.FromIntArray", "Convert a Java array of int to a managed array of System.Int32." },
{ "AndroidJNI.FromLongArray", "Convert a Java array of long to a managed array of System.Int64." },
{ "AndroidJNI.FromObjectArray", "Convert a Java array of java.lang.Object to a managed array of System.IntPtr, representing Java objects." },
{ "AndroidJNI.FromReflectedField", "Converts a java.lang.reflect.Field to a field ID." },
{ "AndroidJNI.FromReflectedMethod", "Converts a java.lang.reflect.Method or java.lang.reflect.Constructor object to a method ID." },
{ "AndroidJNI.FromShortArray", "Convert a Java array of short to a managed array of System.Int16." },
{ "AndroidJNI.GetArrayLength", "Returns the number of elements in the array." },
{ "AndroidJNI.GetBooleanArrayElement", "Returns the value of one element of a primitive array." },
{ "AndroidJNI.GetBooleanField", "This function returns the value of an instance (nonstatic) field of an object." },
{ "AndroidJNI.GetByteArrayElement", "Returns the value of one element of a primitive array." },
{ "AndroidJNI.GetByteField", "This function returns the value of an instance (nonstatic) field of an object." },
{ "AndroidJNI.GetCharArrayElement", "Returns the value of one element of a primitive array." },
{ "AndroidJNI.GetCharField", "This function returns the value of an instance (nonstatic) field of an object." },
{ "AndroidJNI.GetDoubleArrayElement", "Returns the value of one element of a primitive array." },
{ "AndroidJNI.GetDoubleField", "This function returns the value of an instance (nonstatic) field of an object." },
{ "AndroidJNI.GetFieldID", "Returns the field ID for an instance (nonstatic) field of a class." },
{ "AndroidJNI.GetFloatArrayElement", "Returns the value of one element of a primitive array." },
{ "AndroidJNI.GetFloatField", "This function returns the value of an instance (nonstatic) field of an object." },
{ "AndroidJNI.GetIntArrayElement", "Returns the value of one element of a primitive array." },
{ "AndroidJNI.GetIntField", "This function returns the value of an instance (nonstatic) field of an object." },
{ "AndroidJNI.GetLongArrayElement", "Returns the value of one element of a primitive array." },
{ "AndroidJNI.GetLongField", "This function returns the value of an instance (nonstatic) field of an object." },
{ "AndroidJNI.GetMethodID", "Returns the method ID for an instance (nonstatic) method of a class or interface." },
{ "AndroidJNI.GetObjectArrayElement", "Returns an element of an Object array." },
{ "AndroidJNI.GetObjectClass", "Returns the class of an object." },
{ "AndroidJNI.GetObjectField", "This function returns the value of an instance (nonstatic) field of an object." },
{ "AndroidJNI.GetShortArrayElement", "Returns the value of one element of a primitive array." },
{ "AndroidJNI.GetShortField", "This function returns the value of an instance (nonstatic) field of an object." },
{ "AndroidJNI.GetStaticBooleanField", "This function returns the value of a static field of an object." },
{ "AndroidJNI.GetStaticByteField", "This function returns the value of a static field of an object." },
{ "AndroidJNI.GetStaticCharField", "This function returns the value of a static field of an object." },
{ "AndroidJNI.GetStaticDoubleField", "This function returns the value of a static field of an object." },
{ "AndroidJNI.GetStaticFieldID", "Returns the field ID for a static field of a class." },
{ "AndroidJNI.GetStaticFloatField", "This function returns the value of a static field of an object." },
{ "AndroidJNI.GetStaticIntField", "This function returns the value of a static field of an object." },
{ "AndroidJNI.GetStaticLongField", "This function returns the value of a static field of an object." },
{ "AndroidJNI.GetStaticMethodID", "Returns the method ID for a static method of a class." },
{ "AndroidJNI.GetStaticObjectField", "This function returns the value of a static field of an object." },
{ "AndroidJNI.GetStaticShortField", "This function returns the value of a static field of an object." },
{ "AndroidJNI.GetStaticStringField", "This function returns the value of a static field of an object." },
{ "AndroidJNI.GetStringField", "This function returns the value of an instance (nonstatic) field of an object." },
{ "AndroidJNI.GetStringUTFChars", "Returns a managed string object representing the string in modified UTF-8 encoding." },
{ "AndroidJNI.GetStringUTFLength", "Returns the length in bytes of the modified UTF-8 representation of a string." },
{ "AndroidJNI.GetSuperclass", "If clazz represents any class other than the class Object, then this function returns the object that represents the superclass of the class specified by clazz." },
{ "AndroidJNI.GetVersion", "Returns the version of the native method interface." },
{ "AndroidJNI.IsAssignableFrom", "Determines whether an object of clazz1 can be safely cast to clazz2." },
{ "AndroidJNI.IsInstanceOf", "Tests whether an object is an instance of a class." },
{ "AndroidJNI.IsSameObject", "Tests whether two references refer to the same Java object." },
{ "AndroidJNI.NewBooleanArray", "Construct a new primitive array object." },
{ "AndroidJNI.NewByteArray", "Construct a new primitive array object." },
{ "AndroidJNI.NewCharArray", "Construct a new primitive array object." },
{ "AndroidJNI.NewDoubleArray", "Construct a new primitive array object." },
{ "AndroidJNI.NewFloatArray", "Construct a new primitive array object." },
{ "AndroidJNI.NewGlobalRef", "Creates a new global reference to the object referred to by the obj argument." },
{ "AndroidJNI.NewIntArray", "Construct a new primitive array object." },
{ "AndroidJNI.NewLocalRef", "Creates a new local reference that refers to the same object as obj." },
{ "AndroidJNI.NewLongArray", "Construct a new primitive array object." },
{ "AndroidJNI.NewObject", "Constructs a new Java object. The method ID indicates which constructor method to invoke. This ID must be obtained by calling GetMethodID() with <init> as the method name and void (V) as the return type." },
{ "AndroidJNI.NewObjectArray", "Constructs a new array holding objects in class clazz. All elements are initially set to obj." },
{ "AndroidJNI.NewShortArray", "Construct a new primitive array object." },
{ "AndroidJNI.NewStringUTF", "Constructs a new java.lang.String object from an array of characters in modified UTF-8 encoding." },
{ "AndroidJNI.PopLocalFrame", "Pops off the current local reference frame, frees all the local references, and returns a local reference in the previous local reference frame for the given result object." },
{ "AndroidJNI.PushLocalFrame", "Creates a new local reference frame, in which at least a given number of local references can be created." },
{ "AndroidJNI.SetBooleanArrayElement", "Sets the value of one element in a primitive array." },
{ "AndroidJNI.SetBooleanField", "This function sets the value of an instance (nonstatic) field of an object." },
{ "AndroidJNI.SetByteArrayElement", "Sets the value of one element in a primitive array." },
{ "AndroidJNI.SetByteField", "This function sets the value of an instance (nonstatic) field of an object." },
{ "AndroidJNI.SetCharArrayElement", "Sets the value of one element in a primitive array." },
{ "AndroidJNI.SetCharField", "This function sets the value of an instance (nonstatic) field of an object." },
{ "AndroidJNI.SetDoubleArrayElement", "Sets the value of one element in a primitive array." },
{ "AndroidJNI.SetDoubleField", "This function sets the value of an instance (nonstatic) field of an object." },
{ "AndroidJNI.SetFloatArrayElement", "Sets the value of one element in a primitive array." },
{ "AndroidJNI.SetFloatField", "This function sets the value of an instance (nonstatic) field of an object." },
{ "AndroidJNI.SetIntArrayElement", "Sets the value of one element in a primitive array." },
{ "AndroidJNI.SetIntField", "This function sets the value of an instance (nonstatic) field of an object." },
{ "AndroidJNI.SetLongArrayElement", "Sets the value of one element in a primitive array." },
{ "AndroidJNI.SetLongField", "This function sets the value of an instance (nonstatic) field of an object." },
{ "AndroidJNI.SetObjectArrayElement", "Sets an element of an Object array." },
{ "AndroidJNI.SetObjectField", "This function sets the value of an instance (nonstatic) field of an object." },
{ "AndroidJNI.SetShortArrayElement", "Sets the value of one element in a primitive array." },
{ "AndroidJNI.SetShortField", "This function sets the value of an instance (nonstatic) field of an object." },
{ "AndroidJNI.SetStaticBooleanField", "This function ets the value of a static field of an object." },
{ "AndroidJNI.SetStaticByteField", "This function ets the value of a static field of an object." },
{ "AndroidJNI.SetStaticCharField", "This function ets the value of a static field of an object." },
{ "AndroidJNI.SetStaticDoubleField", "This function ets the value of a static field of an object." },
{ "AndroidJNI.SetStaticFloatField", "This function ets the value of a static field of an object." },
{ "AndroidJNI.SetStaticIntField", "This function ets the value of a static field of an object." },
{ "AndroidJNI.SetStaticLongField", "This function ets the value of a static field of an object." },
{ "AndroidJNI.SetStaticObjectField", "This function ets the value of a static field of an object." },
{ "AndroidJNI.SetStaticShortField", "This function ets the value of a static field of an object." },
{ "AndroidJNI.SetStaticStringField", "This function ets the value of a static field of an object." },
{ "AndroidJNI.SetStringField", "This function sets the value of an instance (nonstatic) field of an object." },
{ "AndroidJNI.Throw", "Causes a java.lang.Throwable object to be thrown." },
{ "AndroidJNI.ThrowNew", "Constructs an exception object from the specified class with the message specified by message and causes that exception to be thrown." },
{ "AndroidJNI.ToBooleanArray", "Convert a managed array of System.Boolean to a Java array of boolean." },
{ "AndroidJNI.ToByteArray", "Convert a managed array of System.Byte to a Java array of byte." },
{ "AndroidJNI.ToCharArray", "Convert a managed array of System.Char to a Java array of char." },
{ "AndroidJNI.ToDoubleArray", "Convert a managed array of System.Double to a Java array of double." },
{ "AndroidJNI.ToFloatArray", "Convert a managed array of System.Single to a Java array of float." },
{ "AndroidJNI.ToIntArray", "Convert a managed array of System.Int32 to a Java array of int." },
{ "AndroidJNI.ToLongArray", "Convert a managed array of System.Int64 to a Java array of long." },
{ "AndroidJNI.ToObjectArray", "Convert a managed array of System.IntPtr, representing Java objects, to a Java array of java.lang.Object." },
{ "AndroidJNI.ToReflectedField", "Converts a field ID derived from cls to a java.lang.reflect.Field object." },
{ "AndroidJNI.ToReflectedMethod", "Converts a method ID derived from clazz to a java.lang.reflect.Method or java.lang.reflect.Constructor object." },
{ "AndroidJNI.ToShortArray", "Convert a managed array of System.Int16 to a Java array of short." },
{ "AndroidJNIHelper", "Helper interface for JNI interaction; signature creation and method lookups." },
{ "AndroidJNIHelper-debug", "Set debug to true to log calls through the AndroidJNIHelper." },
{ "AndroidJNIHelper.ConvertFromJNIArray", "Creates a managed array from a Java array." },
{ "AndroidJNIHelper.ConvertToJNIArray", "Creates a Java array from a managed array." },
{ "AndroidJNIHelper.CreateJavaProxy", "Creates a java proxy object which connects to the supplied proxy implementation." },
{ "AndroidJNIHelper.CreateJavaRunnable", "Creates a UnityJavaRunnable object (implements java.lang.Runnable)." },
{ "AndroidJNIHelper.CreateJNIArgArray", "Creates the parameter array to be used as argument list when invoking Java code through CallMethod() in AndroidJNI." },
{ "AndroidJNIHelper.DeleteJNIArgArray", "Deletes any local jni references previously allocated by CreateJNIArgArray()." },
{ "AndroidJNIHelper.GetConstructorID", "Scans a particular Java class for a constructor method matching a signature." },
{ "AndroidJNIHelper.GetFieldID", "Scans a particular Java class for a field matching a name and a signature." },
{ "AndroidJNIHelper.GetMethodID", "Scans a particular Java class for a method matching a name and a signature." },
{ "AndroidJNIHelper.GetSignature", "Creates the JNI signature string for particular object type." },
{ "AndroidPreferredInstallLocation", "Preferred application install location." },
{ "AndroidPreferredInstallLocation.Auto", "Let the OS decide, app doesn't have any preferences." },
{ "AndroidPreferredInstallLocation.ForceInternal", "Force installation into internal memory. Needed for things like Live Wallpapers." },
{ "AndroidPreferredInstallLocation.PreferExternal", "Prefer external, if possible. Install to internal otherwise." },
{ "AndroidSdkVersions", "Supported Android SDK versions." },
{ "AndroidSdkVersions.AndroidApiLevel10", "Android 2.3.3, \"Gingerbread\", API level 10." },
{ "AndroidSdkVersions.AndroidApiLevel11", "Android 3.0, \"Honeycomb\", API level 11." },
{ "AndroidSdkVersions.AndroidApiLevel12", "Android 3.1, \"Honeycomb\", API level 12." },
{ "AndroidSdkVersions.AndroidApiLevel13", "Android 3.2, \"Honeycomb\", API level 13." },
{ "AndroidSdkVersions.AndroidApiLevel14", "Android 4.0, \"Ice Cream Sandwich\", API level 14." },
{ "AndroidSdkVersions.AndroidApiLevel15", "Android 4.0.3, \"Ice Cream Sandwich\", API level 15." },
{ "AndroidSdkVersions.AndroidApiLevel16", "Android 4.1, \"Jelly Bean\", API level 16." },
{ "AndroidSdkVersions.AndroidApiLevel17", "Android 4.2, \"Jelly Bean\", API level 17." },
{ "AndroidSdkVersions.AndroidApiLevel18", "Android 4.3, \"Jelly Bean\", API level 18." },
{ "AndroidSdkVersions.AndroidApiLevel19", "Android 4.4, \"KitKat\", API level 19." },
{ "AndroidSdkVersions.AndroidApiLevel9", "Android 2.3.1, \"Gingerbread\", API level 9." },
{ "AndroidShowActivityIndicatorOnLoading", "Application should show ActivityIndicator when loading." },
{ "AndroidShowActivityIndicatorOnLoading.DontShow", "Don't Show." },
{ "AndroidShowActivityIndicatorOnLoading.InversedLarge", "Inversed Large." },
{ "AndroidShowActivityIndicatorOnLoading.InversedSmall", "Inversed Small." },
{ "AndroidShowActivityIndicatorOnLoading.Large", "Large." },
{ "AndroidShowActivityIndicatorOnLoading.Small", "Small." },
{ "AndroidSplashScreenScale", "Android splash screen scale modes." },
{ "AndroidSplashScreenScale.Center", "Center." },
{ "AndroidSplashScreenScale.ScaleToFill", "Scale to fill." },
{ "AndroidSplashScreenScale.ScaleToFit", "Scale to fit." },
{ "AndroidTargetDevice", "Target Android device architecture." },
{ "AndroidTargetDevice.ARMv7", "ARMv7 only." },
{ "AnimatedValues.AnimBool", "Lerp from 0 - 1." },
{ "AnimatedValues.AnimBool-ctor", "Constructor." },
{ "AnimatedValues.AnimBool-faded", "Retuns the float value of the tween." },
{ "AnimatedValues.AnimBool.Fade", "Returns a value between from and to depending on the current value of the bools animation." },
{ "AnimatedValues.AnimFloat", "An animated float value." },
{ "AnimatedValues.AnimFloat-ctor", "Constructor." },
{ "AnimatedValues.AnimQuaternion", "An animated Quaternion value." },
{ "AnimatedValues.AnimQuaternion-ctor", "Constructor." },
{ "AnimatedValues.AnimVector3", "An animated Vector3 value." },
{ "AnimatedValues.AnimVector3-ctor", "Constructor." },
{ "AnimatedValues.BaseAnimValue_1", "Abstract base class for Animated Values." },
{ "AnimatedValues.BaseAnimValue_1-isAnimating", "Is the value currently animating." },
{ "AnimatedValues.BaseAnimValue_1-speed", "Speed of the tween." },
{ "AnimatedValues.BaseAnimValue_1-target", "Target to tween towards." },
{ "AnimatedValues.BaseAnimValue_1-value", "Current value of the animation." },
{ "Animation", "The animation component is used to play back animations." },
{ "Animation-animatePhysics", "When turned on, animations will be executed in the physics loop. This is only useful in conjunction with kinematic rigidbodies." },
{ "Animation-clip", "The default animation." },
{ "Animation-cullingType", "Controls culling of this Animation component." },
{ "Animation-isPlaying", "Are we playing any animations?" },
{ "Animation-localBounds", "AABB of this Animation animation component in local space." },
{ "Animation-playAutomatically", "Should the default animation clip (Animation.clip) automatically start playing on startup." },
{ "Animation-wrapMode", "How should time beyond the playback range of the clip be treated?" },
{ "Animation.AddClip", "Adds a clip to the animation with name newName." },
{ "Animation.Blend", "Blends the animation named animation towards targetWeight over the next time seconds." },
{ "Animation.CrossFade", "Fades the animation with name animation in over a period of time seconds and fades other animations out." },
{ "Animation.CrossFadeQueued", "Cross fades an animation after previous animations has finished playing." },
{ "Animation.GetClipCount", "Get the number of clips currently assigned to this animation." },
{ "Animation.Index_operator", "Returns the animation state named name." },
{ "Animation.IsPlaying", "Is the animation named name playing?" },
{ "Animation.Play", "Plays animation without any blending." },
{ "Animation.PlayQueued", "Plays an animation after previous animations has finished playing." },
{ "Animation.RemoveClip", "Remove clip from the animation list." },
{ "Animation.Rewind", "Rewinds the animation named name." },
{ "Animation.Sample", "Samples animations at the current state." },
{ "Animation.Stop", "Stops all playing animations that were started with this Animation." },
{ "AnimationBlendMode", "Used by Animation.Play function." },
{ "AnimationBlendMode.Additive", "Animations will be added." },
{ "AnimationBlendMode.Blend", "Animations will be blended." },
{ "AnimationClip", "Stores keyframe based animations." },
{ "AnimationClip-ctor", "Creates a new animation clip." },
{ "AnimationClip-frameRate", "Frame rate at which keyframes are sampled. (Read Only)" },
{ "AnimationClip-length", "Animation length in seconds. (Read Only)" },
{ "AnimationClip-localBounds", "AABB of this Animation Clip in local space of Animation component that it is attached too." },
{ "AnimationClip-wrapMode", "Sets the default wrap mode used in the animation state." },
{ "AnimationClip.AddEvent", "Adds an animation event to the clip." },
{ "AnimationClip.ClearCurves", "Clears all curves from the clip." },
{ "AnimationClip.EnsureQuaternionContinuity", "In order to insure better interpolation of quaternions, call this function after you are finished setting animation curves." },
{ "AnimationClip.SetCurve", "Assigns the curve to animate a specific property." },
{ "AnimationClipCurveData", "An AnimationClipCurveData object contains all the information needed to identify a specific curve in an AnimationClip. The curve animates a specific property of a component / material attached to a game object / animated bone." },
{ "AnimationClipCurveData-curve", "The actual animation curve." },
{ "AnimationClipCurveData-path", "The path of the game object / bone being animated." },
{ "AnimationClipCurveData-propertyName", "The name of the property being animated." },
{ "AnimationClipCurveData-type", "The type of the component / material being animated." },
{ "AnimationClipPair", "This class define a pair of clip used by See Also: AnimationSet." },
{ "AnimationClipPair-originalClip", "The original clip from the controller." },
{ "AnimationClipPair-overrideClip", "The override animation clip." },
{ "AnimationCullingType", "This enum controlls culling of Animation component." },
{ "AnimationCullingType.AlwaysAnimate", "Animation culling is disabled - object is animated even when offscreen." },
{ "AnimationCullingType.BasedOnClipBounds", "Animation is disabled when Animation.localBounds are not visible." },
{ "AnimationCullingType.BasedOnRenderers", "Animation is disabled when renderers are not visible." },
{ "AnimationCullingType.BasedOnUserBounds", "Animation is disabled when Animation.localBounds are not visible." },
{ "AnimationCurve", "A collection of curves form an AnimationClip." },
{ "AnimationCurve-ctor", "Creates an animation curve from arbitrary number of keyframes." },
{ "AnimationCurve-keys", "All keys defined in the animation curve." },
{ "AnimationCurve-length", "The number of keys in the curve. (Read Only)" },
{ "AnimationCurve-postWrapMode", "The behaviour of the animation after the last keyframe." },
{ "AnimationCurve-preWrapMode", "The behaviour of the animation before the first keyframe." },
{ "AnimationCurve.AddKey", "Add a new key to the curve." },
{ "AnimationCurve.EaseInOut", "An ease-in and out curve starting at timeStart, valueStart and ending at timeEnd, valueEnd." },
{ "AnimationCurve.Evaluate", "Evaluate the curve at time." },
{ "AnimationCurve.Index_operator", "Retrieves the key at index. (Read Only)" },
{ "AnimationCurve.Linear", "A straight Line starting at timeStart, valueStart and ending at timeEnd, valueEnd." },
{ "AnimationCurve.MoveKey", "Removes the keyframe at index and inserts key." },
{ "AnimationCurve.RemoveKey", "Removes a key." },
{ "AnimationCurve.SmoothTangents", "Smooth the in and out tangents of the keyframe at index." },
{ "AnimationEvent", "AnimationEvent lets you call a script function similar to SendMessage as part of playing back an animation." },
{ "AnimationEvent-animationState", "The animation state that fired this event (Read Only)." },
{ "AnimationEvent-ctor", "Creates a new animation event." },
{ "AnimationEvent-floatParameter", "Float parameter that is stored in the event and will be sent to the function." },
{ "AnimationEvent-functionName", "The name of the function that will be called." },
{ "AnimationEvent-intParameter", "Int parameter that is stored in the event and will be sent to the function." },
{ "AnimationEvent-messageOptions", "Function call options." },
{ "AnimationEvent-objectReferenceParameter", "Object reference parameter that is stored in the event and will be sent to the function." },
{ "AnimationEvent-stringParameter", "String parameter that is stored in the event and will be sent to the function." },
{ "AnimationEvent-time", "The time at which the event will be fired off." },
{ "AnimationInfo", "Information about what animation clips is played and its weight." },
{ "AnimationInfo-clip", "Animation clip that is played." },
{ "AnimationInfo-weight", "The weight of the animation clip." },
{ "AnimationMode", "AnimationMode is used by the AnimationWindow to store properties modifed by the AnimationClip playback." },
{ "AnimationMode-animatedPropertyColor", "The color used to show that a property is currently being animated." },
{ "AnimationMode.InAnimationMode", "Are we currently in AnimationMode." },
{ "AnimationMode.IsPropertyAnimated", "Is the specified property currently in animation mode and being animated?" },
{ "AnimationMode.SampleAnimationClip", "Samples an AnimationClip on the object and also records any modified properties in AnimationMode." },
{ "AnimationMode.StartAnimationMode", "Starts the animation mode." },
{ "AnimationMode.StopAnimationMode", "Stops Animation mode, reverts all properties that were animated in animation mode." },
{ "AnimationState", "The AnimationState gives full control over animation blending." },
{ "AnimationState-blendMode", "Which blend mode should be used?" },
{ "AnimationState-clip", "The clip that is being played by this animation state." },
{ "AnimationState-enabled", "Enables / disables the animation." },
{ "AnimationState-length", "The length of the animation clip in seconds." },
{ "AnimationState-name", "The name of the animation." },
{ "AnimationState-normalizedSpeed", "The normalized playback speed." },
{ "AnimationState-normalizedTime", "The normalized time of the animation." },
{ "AnimationState-speed", "The playback speed of the animation. 1 is normal playback speed." },
{ "AnimationState-time", "The current time of the animation." },
{ "AnimationState-weight", "The weight of animation." },
{ "AnimationState-wrapMode", "Wrapping mode of the animation." },
{ "AnimationState.AddMixingTransform", "Adds a transform which should be animated. This allows you to reduce the number of animations you have to create." },
{ "AnimationState.RemoveMixingTransform", "Removes a transform which should be animated." },
{ "AnimationUtility", "Editor utility functions for modifying animation clips." },
{ "AnimationUtility.CalculateTransformPath", "Calculates path from root transform to target transform." },
{ "AnimationUtility.GetAllCurves", "Retrieves all curves from a specific animation clip." },
{ "AnimationUtility.GetAnimationClips", "Returns the array of AnimationClips that are referenced in the Animation component." },
{ "AnimationUtility.GetAnimationEvents", "Retrieves all animation events associated with the animation clip." },
{ "AnimationUtility.GetEditorCurve", "Unity automatic combines position curves, scale curves, rotation curves internally." },
{ "AnimationUtility.GetFloatValue", "Retrieves the current float value by sampling a curve value on a specific game object." },
{ "AnimationUtility.SetAnimationClips", "Sets the array of AnimationClips to be referenced in the Animation component." },
{ "AnimationUtility.SetAnimationEvents", "Replaces all animation events in the animation clip." },
{ "AnimationUtility.SetEditorCurve", "Adds an editor curve to the given clip." },
{ "Animator", "Interface to control the Mecanim animation system." },
{ "Animator-applyRootMotion", "Should root motion be applied?" },
{ "Animator-avatar", "Gets/Sets the current Avatar." },
{ "Animator-bodyPosition", "The position of the body center of mass." },
{ "Animator-bodyRotation", "The rotation of the body center of mass." },
{ "Animator-cullingMode", "Controls culling of this Animator component." },
{ "Animator-deltaPosition", "Gets the avatar delta position for the last evaluated frame." },
{ "Animator-deltaRotation", "Gets the avatar delta rotation for the last evaluated frame." },
{ "Animator-feetPivotActive", "Blends pivot point between body center of mass and feet pivot. At 0%, the blending point is body center of mass. At 100%, the blending point is feet pivot." },
{ "Animator-gravityWeight", "The current gravity weight based on current animations that are played." },
{ "Animator-hasRootMotion", "Returns true if the current rig has root motion." },
{ "Animator-hasTransformHierarchy", "Returns true if the object has a transform hierarchy." },
{ "Animator-humanScale", "Returns the scale of the current Avatar for a humanoid rig, (1 by default if the rig is generic)." },
{ "Animator-isHuman", "Returns true if the current rig is humanoid, false if it is generic." },
{ "Animator-isMatchingTarget", "If automatic matching is active." },
{ "Animator-isOptimizable", "Returns true if the current rig is optimizable with AnimatorUtility.OptimizeTransformHierarchy." },
{ "Animator-layerCount", "The AnimatorController layer count." },
{ "Animator-leftFeetBottomHeight", "Get left foot bottom height." },
{ "Animator-pivotPosition", "Get the current position of the pivot." },
{ "Animator-pivotWeight", "Gets the pivot weight." },
{ "Animator-playbackTime", "Sets the playback position in the recording buffer." },
{ "Animator-recorderStartTime", "Start time of the first frame of the buffer relative to the frame at which StartRecording was called." },
{ "Animator-recorderStopTime", "End time of the recorded clip relative to when StartRecording was called." },
{ "Animator-rightFeetBottomHeight", "Get right foot bottom height." },
{ "Animator-rootPosition", "The root position, the position of the game object." },
{ "Animator-rootRotation", "The root rotation, the rotation of the game object." },
{ "Animator-runtimeAnimatorController", "The runtime representation of AnimatorController that controls the Animator." },
{ "Animator-speed", "The playback speed of the Animator. 1 is normal playback speed." },
{ "Animator-stabilizeFeet", "Automatic stabilization of feet during transition and blending." },
{ "Animator-targetPosition", "Returns the position of the target specified by SetTarget(AvatarTarget targetIndex, float targetNormalizedTime))." },
{ "Animator-targetRotation", "Returns the rotation of the target specified by SetTarget(AvatarTarget targetIndex, float targetNormalizedTime))." },
{ "Animator-updateMode", "Specifies the update mode of the Animator." },
{ "Animator.CrossFade", "Create a dynamic transition between the current state and the destination state." },
{ "Animator.GetAnimatorTransitionInfo", "Gets the Transition information on a specified AnimatorController layer." },
{ "Animator.GetBoneTransform", "Returns transform mapped to this human bone id." },
{ "Animator.GetBool", "Gets the value of a bool parameter." },
{ "Animator.GetCurrentAnimationClipState", "Gets the list of AnimationInfo currently played by the current state." },
{ "Animator.GetCurrentAnimatorStateInfo", "Gets the current State information on a specified AnimatorController layer." },
{ "Animator.GetFloat", "Gets the value of a float parameter." },
{ "Animator.GetIKPosition", "Gets the position of an IK goal." },
{ "Animator.GetIKPositionWeight", "Gets the translative weight of an IK goal (0 = at the original animation before IK, 1 = at the goal)." },
{ "Animator.GetIKRotation", "Gets the rotation of an IK goal." },
{ "Animator.GetIKRotationWeight", "Gets the rotational weight of an IK goal (0 = rotation before IK, 1 = rotation at the IK goal)." },
{ "Animator.GetInteger", "Gets the value of an integer parameter." },
{ "Animator.GetLayerName", "Gets name of the layer." },
{ "Animator.GetLayerWeight", "Gets the layer's current weight." },
{ "Animator.GetNextAnimationClipState", "Gets the list of AnimationInfo currently played by the next state." },
{ "Animator.GetNextAnimatorStateInfo", "Gets the next State information on a specified AnimatorController layer." },
{ "Animator.InterruptMatchTarget", "Interrupts the automatic target matching." },
{ "Animator.IsInTransition", "Is the specified AnimatorController layer in a transition." },
{ "Animator.IsParameterControlledByCurve", "Returns true if a parameter is controlled by an additional curve on an animation." },
{ "Animator.MatchTarget", "Automatically adjust the gameobject position and rotation so that the AvatarTarget reaches the matchPosition when the current state is at the specified progress." },
{ "Animator.Play", "Plays a state." },
{ "Animator.Rebind", "Rebind all the animated properties and mesh data with the Animator." },
{ "Animator.ResetTrigger", "Resets the trigger parameter to false." },
{ "Animator.SetBool", "Sets the value of a bool parameter." },
{ "Animator.SetFloat", "Sets the value of a float parameter." },
{ "Animator.SetIKPosition", "Sets the position of an IK goal." },
{ "Animator.SetIKPositionWeight", "Sets the translative weight of an IK goal (0 = at the original animation before IK, 1 = at the goal)." },
{ "Animator.SetIKRotation", "Sets the rotation of an IK goal." },
{ "Animator.SetIKRotationWeight", "Sets the rotational weight of an IK goal (0 = rotation before IK, 1 = rotation at the IK goal)." },
{ "Animator.SetInteger", "Sets the value of an integer parameter." },
{ "Animator.SetLayerWeight", "Sets the layer's current weight." },
{ "Animator.SetLookAtPosition", "Sets the look at position." },
{ "Animator.SetLookAtWeight", "Set look at weights." },
{ "Animator.SetTarget", "Sets an AvatarTarget and a targetNormalizedTime for the current state." },
{ "Animator.SetTrigger", "Sets a trigger parameter to active." },
{ "Animator.StartPlayback", "Sets the animator in playback mode." },
{ "Animator.StartRecording", "Sets the animator in recording mode, and allocates a circular buffer of size frameCount." },
{ "Animator.StopPlayback", "Stops the animator playback mode. When playback stops, the avatar resumes getting control from game logic." },
{ "Animator.StopRecording", "Stops animator record mode." },
{ "Animator.StringToHash", "Generates an parameter id from a string." },
{ "Animator.Update", "Evaluates the animator based on deltaTime." },
{ "AnimatorCullingMode", "Culling mode for the Animator." },
{ "AnimatorCullingMode.AlwaysAnimate", "Always animate the entire character. Object is animated even when offscreen." },
{ "AnimatorCullingMode.BasedOnRenderers", "Animation is disabled when renderers are not visible." },
{ "AnimatorOverrideController", "Interface to control AnimatorOverrideController." },
{ "AnimatorOverrideController-clips", "Returns the list of orignal clip from the controller and their override clip." },
{ "AnimatorOverrideController-runtimeAnimatorController", "The Controller that the AnimatorOverrideController overrides." },
{ "AnimatorOverrideController.Index_operator", "Returns either the overriding clip if set or the original clip named name." },
{ "AnimatorStateInfo", "Information about the current or next state." },
{ "AnimatorStateInfo-length", "Current duration of the state." },
{ "AnimatorStateInfo-loop", "Is the state looping." },
{ "AnimatorStateInfo-nameHash", "Name of the State." },
{ "AnimatorStateInfo-normalizedTime", "Normalized time of the State." },
{ "AnimatorStateInfo-tagHash", "The Tag of the State." },
{ "AnimatorStateInfo.IsName", "Does name match the name of the active state in the statemachine?" },
{ "AnimatorStateInfo.IsTag", "Does tag match the tag of the active state in the statemachine." },
{ "AnimatorTransitionInfo", "Information about the current transition." },
{ "AnimatorTransitionInfo-nameHash", "The unique name of the Transition." },
{ "AnimatorTransitionInfo-normalizedTime", "Normalized time of the Transition." },
{ "AnimatorTransitionInfo-userNameHash", "The user-specidied name of the Transition." },
{ "AnimatorTransitionInfo.IsName", "Does name match the name of the active Transition." },
{ "AnimatorTransitionInfo.IsUserName", "Does userName match the name of the active Transition." },
{ "AnimatorUpdateMode", "The update mode of the Animator." },
{ "AnimatorUpdateMode.AnimatePhysics", "Updates the animator during the physic loop in order to have the animation system synchronized with the physics engine." },
{ "AnimatorUpdateMode.Normal", "Normal update of the animator." },
{ "AnimatorUpdateMode.UnscaledTime", "Animator updates independently of Time.timeScale." },
{ "AnisotropicFiltering", "Anisotropic filtering mode." },
{ "AnisotropicFiltering.Disable", "Disable anisotropic filtering for all textures." },
{ "AnisotropicFiltering.Enable", "Enable anisotropic filtering, as set for each texture." },
{ "AnisotropicFiltering.ForceEnable", "Enable anisotropic filtering for all textures." },
{ "ApiCompatibilityLevel", ".NET API compatibility level." },
{ "ApiCompatibilityLevel.NET_2_0", ".NET 2.0." },
{ "ApiCompatibilityLevel.NET_2_0_Subset", ".NET 2.0 Subset." },
{ "Application", "Access to application run-time data." },
{ "Application-absoluteURL", "The absolute path to the web player data file (Read Only)." },
{ "Application-backgroundLoadingPriority", "Priority of background loading thread." },
{ "Application-dataPath", "Contains the path to the game data folder (Read Only)." },
{ "Application-genuine", "Returns false if application is altered in any way after it was built." },
{ "Application-genuineCheckAvailable", "Returns true if application integrity can be confirmed." },
{ "Application-internetReachability", "Returns the type of Internet reachability currently possible on the device." },
{ "Application-isEditor", "Are we running inside the Unity editor? (Read Only)" },
{ "Application-isLoadingLevel", "Is some level being loaded? (Read Only)" },
{ "Application-isPlaying", "Returns true when in any kind of player (Read Only)." },
{ "Application-isWebPlayer", "Are we running inside a web player? (Read Only)" },
{ "Application-levelCount", "The total number of levels available (Read Only)." },
{ "Application-loadedLevel", "The level index that was last loaded (Read Only)." },
{ "Application-loadedLevelName", "The name of the level that was last loaded (Read Only)." },
{ "Application-persistentDataPath", "Contains the path to a persistent data directory (Read Only)." },
{ "Application-platform", "Returns the platform the game is running (Read Only)." },
{ "Application-runInBackground", "Should the player be running when the application is in the background?" },
{ "Application-srcValue", "The path to the web player data file relative to the html file (Read Only)." },
{ "Application-streamedBytes", "How many bytes have we downloaded from the main unity web stream (Read Only)." },
{ "Application-streamingAssetsPath", "Contains the path to the StreamingAssets folder (Read Only)." },
{ "Application-systemLanguage", "The language the user's operating system is running in." },
{ "Application-targetFrameRate", "Instructs game to try to render at a specified frame rate." },
{ "Application-temporaryCachePath", "Contains the path to a temporary data / cache directory (Read Only)." },
{ "Application-unityVersion", "The version of the Unity runtime used to play the content." },
{ "Application-webSecurityEnabled", "Indicates whether Unity's webplayer security model is enabled." },
{ "Application.CancelQuit", "Cancels quitting the application. This is useful for showing a splash screen at the end of a game." },
{ "Application.CanStreamedLevelBeLoaded", "Can the streamed level be loaded?" },
{ "Application.CaptureScreenshot", "Captures a screenshot at path filename as a PNG file." },
{ "Application.ExternalCall", "Calls a function in the containing web page (Web Player only)." },
{ "Application.ExternalEval", "Evaluates script snippet in the containing web page (Web Player only)." },
{ "Application.GetStreamProgressForLevel", "How far has the download progressed? [0...1]." },
{ "Application.HasProLicense", "Is Unity activated with the Pro license?" },
{ "Application.HasUserAuthorization", "Check if the user has authorized use of the webcam or microphone in the Web Player." },
{ "Application.LoadLevel", "Loads the level by its name or index." },
{ "Application.LoadLevelAdditive", "Loads a level additively." },
{ "Application.LoadLevelAdditiveAsync", "Loads the level additively and asynchronously in the background." },
{ "Application.LoadLevelAsync", "Loads the level asynchronously in the background." },
{ "Application.LogCallback", "Use this delegate type with RegisterLogCallback to monitor what gets logged." },
{ "Application.OpenURL", "Opens the url in a browser." },
{ "Application.Quit", "Quits the player application." },
{ "Application.RegisterLogCallback", "Register a delegate to be called on log messages." },
{ "Application.RegisterLogCallbackThreaded", "Register a delegate to be called on log messages." },
{ "Application.RequestUserAuthorization", "Request authorization to use the webcam or microphone in the Web Player." },
{ "Array", "Arrays allow you to store multiple objects in a single variable." },
{ "Array-length", "The length property of the array that returns or sets the number of elements in array." },
{ "Array.Add", "Adds value to the end of the array." },
{ "Array.Clear", "Empties the array. The length of the array will be zero." },
{ "Array.Concat", "Concat joins two or more arrays." },
{ "Array.Join", "Joins the contents of an array into one string." },
{ "Array.Pop", "Removes the last element of the array and returns it." },
{ "Array.Push", "Adds value to the end of the array." },
{ "Array.RemoveAt", "Removes the element at index from the array." },
{ "Array.Shift", "Removes the first element of the array and returns it." },
{ "Array.Sort", "Sorts all Array elements." },
{ "Array.Unshift", "Unshift adds one or more elements to the beginning of an array and returns the new length of the array." },
{ "ArrayUtility", "Helpers for builtin arrays ..." },
{ "ArrayUtility.Add", "Appends item to the end of array." },
{ "ArrayUtility.AddRange", "Appends items to the end of array." },
{ "ArrayUtility.ArrayEquals", "Compares two arrays." },
{ "ArrayUtility.Clear", "Clears the array." },
{ "ArrayUtility.Contains", "Determines if the array contains the item." },
{ "ArrayUtility.FindIndex", "Find the index of the first element that satisfies the predicate." },
{ "ArrayUtility.IndexOf", "Index of first element with value value." },
{ "ArrayUtility.Insert", "Inserts item item at position index." },
{ "ArrayUtility.LastIndexOf", "Index of the last element with value value." },
{ "ArrayUtility.Remove", "Removes item from array." },
{ "ArrayUtility.RemoveAt", "Remove element at position index." },
{ "AspectRatio", "Aspect ratio." },
{ "AspectRatio.Aspect16by10", "16:10 aspect ratio." },
{ "AspectRatio.Aspect16by9", "16:9 aspect ratio." },
{ "AspectRatio.Aspect4by3", "4:3 aspect ratio." },
{ "AspectRatio.Aspect5by4", "5:4 aspect ratio." },
{ "AspectRatio.AspectOthers", "Undefined aspect ratios." },
{ "AssemblyIsEditorAssembly", "Assembly level attribute. Any classes in an assembly with this attribute will be considered to be Editor Classes." },
{ "AssemblyIsEditorAssembly-ctor", "Constructor." },
{ "AssetBundle", "AssetBundles let you stream additional assets via the WWW class and instantiate them at runtime. AssetBundles are created via BuildPipeline.BuildAssetBundle." },
{ "AssetBundle-mainAsset", "Main asset that was supplied when building the asset bundle (Read Only)." },
{ "AssetBundle.Contains", "Check if an AssetBundle contains a specific object." },
{ "AssetBundle.CreateFromFile", "Loads an asset bundle from a disk." },
{ "AssetBundle.CreateFromMemory", "Asynchronously create an AssetBundle from a memory region." },
{ "AssetBundle.Load", "Loads object with name from the bundle." },
{ "AssetBundle.LoadAll", "Loads all objects contained in the asset bundle that inherit from type." },
{ "AssetBundle.LoadAsync", "Asynchronously loads object with name of a given type from the bundle." },
{ "AssetBundle.Unload", "Unloads all assets in the bundle." },
{ "AssetBundleCreateRequest", "Asynchronous create request for an AssetBundle." },
{ "AssetBundleCreateRequest-assetBundle", "Asset object being loaded (Read Only)." },
{ "AssetBundleRequest", "Asynchronous load request from an AssetBundle." },
{ "AssetBundleRequest-asset", "Asset object being loaded (Read Only)." },
{ "AssetDatabase", "An Interface for accessing assets and performing operations on assets." },
{ "AssetDatabase.AddObjectToAsset", "Adds objectToAdd to an existing asset at path." },
{ "AssetDatabase.AssetPathToGUID", "Get the GUID for the asset at path." },
{ "AssetDatabase.ClearLabels", "Removes all labels attached to an asset." },
{ "AssetDatabase.Contains", "Is object an asset?" },
{ "AssetDatabase.CopyAsset", "Duplicates the asset at path and stores it at newPath." },
{ "AssetDatabase.CreateAsset", "Creates a new asset at path." },
{ "AssetDatabase.CreateFolder", "Create a new folder." },
{ "AssetDatabase.DeleteAsset", "Deletes the asset file at path." },
{ "AssetDatabase.ExportPackage", "Exports the assets identified by assetPathNames to a unitypackage file in fileName." },
{ "AssetDatabase.FindAssets", "Search the assetdatabase using a searchfilter string." },
{ "AssetDatabase.GenerateUniqueAssetPath", "Creates a new unique path for an asset." },
{ "AssetDatabase.GetAssetOrScenePath", "Returns the path name relative to the project folder where the asset is stored." },
{ "AssetDatabase.GetAssetPath", "Returns the path name relative to the project folder where the asset is stored." },
{ "AssetDatabase.GetCachedIcon", "Retrieves an icon for the asset at the given asset path." },
{ "AssetDatabase.GetDependencies", "Given an asset pathName, returns the list of all assets it depends on." },
{ "AssetDatabase.GetLabels", "Returns all labels attached to a given asset." },
{ "AssetDatabase.GetTextMetaDataPathFromAssetPath", "Gets the path to the text .meta file associated with an asset." },
{ "AssetDatabase.GUIDToAssetPath", "Translate a GUID to its current asset path." },
{ "AssetDatabase.ImportAsset", "Import asset at path." },
{ "AssetDatabase.ImportPackage", "Imports package at packagePath into the current project." },
{ "AssetDatabase.IsMainAsset", "Is asset a main asset in the project window?" },
{ "AssetDatabase.IsOpenForEdit", "Use IsOpenForEdit to determine if the asset is open for edit by the version control." },
{ "AssetDatabase.IsSubAsset", "Does the asset form part of another asset?" },
{ "AssetDatabase.LoadAllAssetRepresentationsAtPath", "Returns all asset representations at assetPath." },
{ "AssetDatabase.LoadAllAssetsAtPath", "Returns an array of all asset objects at assetPath." },
{ "AssetDatabase.LoadAssetAtPath", "Returns the first asset object of type type at given path assetPath." },
{ "AssetDatabase.LoadMainAssetAtPath", "Returns the main asset object at assetPath." },
{ "AssetDatabase.MoveAsset", "Move an asset file from one folder to another." },
{ "AssetDatabase.MoveAssetToTrash", "Moves the asset at path to the trash." },
{ "AssetDatabase.OpenAsset", "Opens the asset with associated application." },
{ "AssetDatabase.Refresh", "Import any changed assets." },
{ "AssetDatabase.RenameAsset", "Rename an asset file." },
{ "AssetDatabase.SaveAssets", "Writes all unsaved asset changes to disk." },
{ "AssetDatabase.SetLabels", "Replaces that list of labels on an asset." },
{ "AssetDatabase.StartAssetEditing", "Begin Asset importing. This lets you group several asset imports together into one larger import." },
{ "AssetDatabase.StopAssetEditing", "Stop Asset importing. This lets you group several asset imports together into one larger import." },
{ "AssetDatabase.ValidateMoveAsset", "Checks if an asset file can be moved from one folder to another. (Without actually moving the file)." },
{ "AssetDatabase.WriteImportSettingsIfDirty", "Writes the import settings to disk." },
{ "AssetDeleteResult.DidDelete", "Tells Unity that the asset was deleted by the callback. Unity will not try to delete the asset, but will delete the cached version and preview file." },
{ "AssetDeleteResult.DidNotDelete", "Tells the internal implementation that the callback did not delete the asset. The asset will be delete by the internal implementation." },
{ "AssetDeleteResult.FailedDelete", "Tells Unity that the file cannot be deleted and Unity should leave it alone." },
{ "AssetImporter", "Base class from which asset importers for specific asset types derive." },
{ "AssetImporter-assetPath", "The path name of the asset for this importer. (Read Only)" },
{ "AssetImporter-userData", "Get or set any user data." },
{ "AssetImporter.GetAtPath", "Retrieves the asset importer for the asset at path." },
{ "AssetModificationProcessor", "AssetModificationProcessor lets you hook into saving of serialized assets and scenes which are edited inside Unity." },
{ "AssetModificationProcessor.IsOpenForEdit", "This is called by Unity when inspecting an asset to determine if an editor should be disabled." },
{ "AssetModificationProcessor.OnWillCreateAsset", "This is called by Unity when it is about to create an asset not imported by the user, eg. \".meta\" files." },
{ "AssetModificationProcessor.OnWillDeleteAsset", "This is called by Unity when it is about to delete an asset from disk." },
{ "AssetModificationProcessor.OnWillMoveAsset", "This is called by Unity when it is about to move an asset on disk." },
{ "AssetModificationProcessor.OnWillSaveAssets", "This is called by Unity when it is about to write serialized assets or scene files to disk." },
{ "AssetMoveResult.DidMove", "Tells the internal implementation that the script moved the asset physically on disk." },
{ "AssetMoveResult.DidNotMove", "Tells the internal implementation that the asset was not moved physically on disk by the script." },
{ "AssetMoveResult.FailedMove", "Tells the internal implementation that the script could not move the assets." },
{ "AssetPostprocessor", "AssetPostprocessor lets you hook into the import pipeline and run scripts prior or after importing assets." },
{ "AssetPostprocessor-assetImporter", "Reference to the asset importer." },
{ "AssetPostprocessor-assetPath", "The path name of the asset being imported." },
{ "AssetPostprocessor.GetPostprocessOrder", "Override the order in which importers are processed." },
{ "AssetPostprocessor.GetVersion", "Returns the version of the asset postprocessor." },
{ "AssetPostprocessor.LogError", "Logs an import error message to the console." },
{ "AssetPostprocessor.LogWarning", "Logs an import warning to the console." },
{ "AssetPostprocessor.OnAssignMaterialModel", "Feeds a source material." },
{ "AssetPostprocessor.OnPostprocessAllAssets", "This is called after importing of any number of assets is complete (when the Assets progress bar has reached the end)." },
{ "AssetPostprocessor.OnPostprocessAudio", "Add this function in a subclass to get a notification when an audio clip has completed importing." },
{ "AssetPostprocessor.OnPostprocessGameObjectWithUserProperties", "Gets called for each GameObject that had at least one userpropery attached to it in the imported file." },
{ "AssetPostprocessor.OnPostprocessModel", "Add this function in a subclass to get a notification when a model has completed importing." },
{ "AssetPostprocessor.OnPostprocessTexture", "Add this function in a subclass to get a notification when a texture has completed importing just before." },
{ "AssetPostprocessor.OnPreprocessAudio", "Add this function in a subclass to get a notification just before an audio clip is being imported." },
{ "AssetPostprocessor.OnPreprocessModel", "Add this function in a subclass to get a notification just before a model (.fbx, .mb file etc.) is imported." },
{ "AssetPostprocessor.OnPreprocessTexture", "Add this function in a subclass to get a notification just before the texture importer is run." },
{ "AssetPreview.GetAssetPreview", "Returns a preview texture for an asset." },
{ "AssetPreview.GetMiniThumbnail", "Returns the thumbnail for an object (like the ones you see in the project view)." },
{ "AssetPreview.GetMiniTypeThumbnail", "Returns the thumbnail for the type." },
{ "AsyncOperation", "Asynchronous operation coroutine." },
{ "AsyncOperation-allowSceneActivation", "Allow scenes to be activated as soon as it is ready." },
{ "AsyncOperation-isDone", "Has the operation finished? (Read Only)" },
{ "AsyncOperation-priority", "Priority lets you tweak in which order async operation calls will be performed." },
{ "AsyncOperation-progress", "What's the operation's progress. (Read Only)" },
{ "AudioChorusFilter", "The Audio Chorus Filter takes an Audio Clip and processes it creating a chorus effect." },
{ "AudioChorusFilter-delay", "Chorus delay in ms. 0.1 to 100.0. Default = 40.0 ms." },
{ "AudioChorusFilter-depth", "Chorus modulation depth. 0.0 to 1.0. Default = 0.03." },
{ "AudioChorusFilter-dryMix", "Volume of original signal to pass to output. 0.0 to 1.0. Default = 0.5." },
{ "AudioChorusFilter-rate", "Chorus modulation rate in hz. 0.0 to 20.0. Default = 0.8 hz." },
{ "AudioChorusFilter-wetMix1", "Volume of 1st chorus tap. 0.0 to 1.0. Default = 0.5." },
{ "AudioChorusFilter-wetMix2", "Volume of 2nd chorus tap. This tap is 90 degrees out of phase of the first tap. 0.0 to 1.0. Default = 0.5." },
{ "AudioChorusFilter-wetMix3", "Volume of 3rd chorus tap. This tap is 90 degrees out of phase of the second tap. 0.0 to 1.0. Default = 0.5." },
{ "AudioClip", "A container for audio data." },
{ "AudioClip-channels", "Channels in audio clip. (Read Only)" },
{ "AudioClip-frequency", "Sample frequency. (Read Only)" },
{ "AudioClip-isReadyToPlay", "Is a streamed audio clip ready to play? (Read Only)" },
{ "AudioClip-length", "The length of the audio clip in seconds. (Read Only)" },
{ "AudioClip-samples", "The length of the audio clip in samples. (Read Only)" },
{ "AudioClip.Create", "Creates a user AudioClip with a name and with the given length in samples, channels and frequency." },
{ "AudioClip.GetData", "Fills an array with sample data from the clip." },
{ "AudioClip.PCMReaderCallback", "Delegate called each time AudioClip reads data." },
{ "AudioClip.PCMSetPositionCallback", "Delegate called each time AudioClip changes read position." },
{ "AudioClip.SetData", "Set sample data in a clip." },
{ "AudioDistortionFilter", "The Audio Distortion Filter distorts the sound from an AudioSource or." },
{ "AudioDistortionFilter-distortionLevel", "Distortion value. 0.0 to 1.0. Default = 0.5." },
{ "AudioEchoFilter", "The Audio Echo Filter repeats a sound after a given Delay, attenuating." },
{ "AudioEchoFilter-decayRatio", "Echo decay per delay. 0 to 1. 1.0 = No decay, 0.0 = total decay (i.e. simple 1 line delay). Default = 0.5." },
{ "AudioEchoFilter-delay", "Echo delay in ms. 10 to 5000. Default = 500." },
{ "AudioEchoFilter-dryMix", "Volume of original signal to pass to output. 0.0 to 1.0. Default = 1.0." },
{ "AudioEchoFilter-wetMix", "Volume of echo signal to pass to output. 0.0 to 1.0. Default = 1.0." },
{ "AudioHighPassFilter", "The Audio High Pass Filter passes high frequencies of an AudioSource and." },
{ "AudioHighPassFilter-cutoffFrequency", "Highpass cutoff frequency in hz. 10.0 to 22000.0. Default = 5000.0." },
{ "AudioHighPassFilter-highpassResonaceQ", "Determines how much the filter's self-resonance isdampened." },
{ "AudioImporter", "Audio importer lets you modify AudioClip import settings from editor scripts." },
{ "AudioImporter-compressionBitrate", "Compression bitrate." },
{ "AudioImporter-forceToMono", "Force this clip to mono?" },
{ "AudioImporter-format", "Format of imported audio." },
{ "AudioImporter-hardware", "Use hardware voice/decoder if available." },
{ "AudioImporter-loadType", "Set/get the way Unity is loading the Audio data." },
{ "AudioImporter-loopable", "Is this clip loopable?" },
{ "AudioImporter-threeD", "Is this clip a 2D or 3D sound?" },
{ "AudioImporterFormat", "Imported audio format for AudioImporter." },
{ "AudioImporterFormat.Compressed", "Ogg compressed audio." },
{ "AudioImporterFormat.Native", "Native format." },
{ "AudioImporterLoadType", "The way we load audio assets AudioImporter." },
{ "AudioImporterLoadType.CompressedInMemory", "Keep audio compressed in memory." },
{ "AudioImporterLoadType.DecompressOnLoad", "Decompress audio data on load." },
{ "AudioImporterLoadType.StreamFromDisc", "Stream audio from disc." },
{ "AudioListener", "Representation of a listener in 3D space." },
{ "AudioListener-pause", "The paused state of the audio system." },
{ "AudioListener-velocityUpdateMode", "This lets you set whether the Audio Listener should be updated in the fixed or dynamic update." },
{ "AudioListener-volume", "Controls the game sound volume (0.0 to 1.0)." },
{ "AudioListener.GetOutputData", "Returns a block of the listener (master)'s output data." },
{ "AudioListener.GetSpectrumData", "Returns a block of the listener (master)'s spectrum data." },
{ "AudioLowPassFilter", "The Audio Low Pass Filter filter passes low frequencies of an." },
{ "AudioLowPassFilter-cutoffFrequency", "Lowpass cutoff frequency in hz. 10.0 to 22000.0. Default = 5000.0." },
{ "AudioLowPassFilter-lowpassResonaceQ", "Determines how much the filter's self-resonance is dampened." },
{ "AudioReverbFilter", "The Audio Reverb Filter takes an Audio Clip and distortionates it in a." },
{ "AudioReverbFilter-decayHFRatio", "Decay HF Ratio : High-frequency to low-frequency decay time ratio. Ranges from 0.1 to 2.0. Default is 0.5." },
{ "AudioReverbFilter-decayTime", "Reverberation decay time at low-frequencies in seconds. Ranges from 0.1 to 20.0. Default is 1.0." },
{ "AudioReverbFilter-density", "Reverberation density (modal density) in percent. Ranges from 0.0 to 100.0. Default is 100.0." },
{ "AudioReverbFilter-diffusion", "Reverberation diffusion (echo density) in percent. Ranges from 0.0 to 100.0. Default is 100.0." },
{ "AudioReverbFilter-dryLevel", "Mix level of dry signal in output in mB. Ranges from -10000.0 to 0.0. Default is 0." },
{ "AudioReverbFilter-hfReference", "Reference high frequency in Hz. Ranges from 20.0 to 20000.0. Default is 5000.0." },
{ "AudioReverbFilter-lFReference", "Reference low-frequency in Hz. Ranges from 20.0 to 1000.0. Default is 250.0." },
{ "AudioReverbFilter-reflectionsDelay", "Late reverberation level relative to room effect in mB. Ranges from -10000.0 to 2000.0. Default is 0.0." },
{ "AudioReverbFilter-reflectionsLevel", "Early reflections level relative to room effect in mB. Ranges from -10000.0 to 1000.0. Default is -10000.0." },
{ "AudioReverbFilter-reverbDelay", "Late reverberation delay time relative to first reflection in seconds. Ranges from 0.0 to 0.1. Default is 0.04." },
{ "AudioReverbFilter-reverbLevel", "Late reverberation level relative to room effect in mB. Ranges from -10000.0 to 2000.0. Default is 0.0." },
{ "AudioReverbFilter-reverbPreset", "Set/Get reverb preset properties." },
{ "AudioReverbFilter-room", "Room effect level at low frequencies in mB. Ranges from -10000.0 to 0.0. Default is 0.0." },
{ "AudioReverbFilter-roomHF", "Room effect high-frequency level re. low frequency level in mB. Ranges from -10000.0 to 0.0. Default is 0.0." },
{ "AudioReverbFilter-roomLF", "Room effect low-frequency level in mB. Ranges from -10000.0 to 0.0. Default is 0.0." },
{ "AudioReverbFilter-roomRolloff", "Rolloff factor for room effect. Ranges from 0.0 to 10.0. Default is 10.0." },
{ "AudioReverbPreset", "Reverb presets used by the Reverb Zone class and the audio reverb filter." },
{ "AudioReverbPreset.Alley", "Alley preset." },
{ "AudioReverbPreset.Arena", "Arena preset." },
{ "AudioReverbPreset.Auditorium", "Auditorium preset." },
{ "AudioReverbPreset.Bathroom", "Bathroom preset." },
{ "AudioReverbPreset.CarpetedHallway", "Carpeted hallway preset." },
{ "AudioReverbPreset.Cave", "Cave preset." },
{ "AudioReverbPreset.City", "City preset." },
{ "AudioReverbPreset.Concerthall", "Concert hall preset." },
{ "AudioReverbPreset.Dizzy", "Dizzy preset." },
{ "AudioReverbPreset.Drugged", "Drugged preset." },
{ "AudioReverbPreset.Forest", "Forest preset." },
{ "AudioReverbPreset.Generic", "Generic preset." },
{ "AudioReverbPreset.Hallway", "Hallway preset." },
{ "AudioReverbPreset.Hangar", "Hangar preset." },
{ "AudioReverbPreset.Livingroom", "Livingroom preset." },
{ "AudioReverbPreset.Mountains", "Mountains preset." },
{ "AudioReverbPreset.Off", "No reverb preset selected." },
{ "AudioReverbPreset.PaddedCell", "Padded cell preset." },
{ "AudioReverbPreset.ParkingLot", "Parking Lot preset." },
{ "AudioReverbPreset.Plain", "Plain preset." },
{ "AudioReverbPreset.Psychotic", "Psychotic preset." },
{ "AudioReverbPreset.Quarry", "Quarry preset." },
{ "AudioReverbPreset.Room", "Room preset." },
{ "AudioReverbPreset.SewerPipe", "Sewer pipe preset." },
{ "AudioReverbPreset.StoneCorridor", "Stone corridor preset." },
{ "AudioReverbPreset.Stoneroom", "Stoneroom preset." },
{ "AudioReverbPreset.Underwater", "Underwater presset." },
{ "AudioReverbPreset.User", "User defined preset." },
{ "AudioReverbZone", "Reverb Zones are used when you want to create location based ambient effects in the scene." },
{ "AudioReverbZone-decayHFRatio", "High-frequency to mid-frequency decay time ratio." },
{ "AudioReverbZone-decayTime", "Reverberation decay time at mid frequencies." },
{ "AudioReverbZone-density", "Value that controls the modal density in the late reverberation decay." },
{ "AudioReverbZone-diffusion", "Value that controls the echo density in the late reverberation decay." },
{ "AudioReverbZone-maxDistance", "The distance from the centerpoint that the reverb will not have any effect. Default = 15.0." },
{ "AudioReverbZone-minDistance", "The distance from the centerpoint that the reverb will have full effect at. Default = 10.0." },
{ "AudioReverbZone-reflections", "Early reflections level relative to room effect." },
{ "AudioReverbZone-reflectionsDelay", "Initial reflection delay time." },
{ "AudioReverbZone-reverb", "Late reverberation level relative to room effect." },
{ "AudioReverbZone-reverbDelay", "Late reverberation delay time relative to initial reflection." },
{ "AudioReverbZone-reverbPreset", "Set/Get reverb preset properties." },
{ "AudioReverbZone-room", "Room effect level (at mid frequencies)." },
{ "AudioReverbZone-roomHF", "Relative room effect level at high frequencies." },
{ "AudioReverbZone-roomLF", "Relative room effect level at low frequencies." },
{ "AudioReverbZone-roomRolloffFactor", "Like rolloffscale in global settings, but for reverb room size effect." },
{ "AudioReverbZone.HFReference", "Reference high frequency (hz)." },
{ "AudioReverbZone.LFReference", "Reference low frequency (hz)." },
{ "AudioRolloffMode", "Rolloff modes that a 3D sound can have in an audio source." },
{ "AudioRolloffMode.Custom", "Use this when you want to use a custom rolloff." },
{ "AudioRolloffMode.Linear", "Use this mode when you want to lower the volume of your sound over the distance." },
{ "AudioRolloffMode.Logarithmic", "Use this mode when you want a real-world rolloff." },
{ "AudioSettings", "Controls the global audio settings from script." },
{ "AudioSettings-driverCaps", "Returns the speaker mode capability of the current audio driver. (Read Only)" },
{ "AudioSettings-dspTime", "Returns the current time of the audio system." },
{ "AudioSettings-outputSampleRate", "Get and set the mixer's current output rate." },
{ "AudioSettings-speakerMode", "Sets or gets the current speaker mode. Default is 2 channel stereo." },
{ "AudioSettings.GetDSPBufferSize", "Get or set the mixer's buffer size in samples." },
{ "AudioSettings.SetDSPBufferSize", "Get or set the mixer's buffer size in samples." },
{ "AudioSource", "A representation of audio sources in 3D." },
{ "AudioSource-bypassEffects", "Bypass effects (Applied from filter components or global listener filters)." },
{ "AudioSource-clip", "The default AudioClip to play." },
{ "AudioSource-dopplerLevel", "Sets the Doppler scale for this AudioSource." },
{ "AudioSource-ignoreListenerPause", "Allows AudioSource to play even though AudioListener.pause is set to true. This is useful for the menu element sounds or background music in pause menus." },
{ "AudioSource-ignoreListenerVolume", "This makes the audio source not take into account the volume of the audio listener." },
{ "AudioSource-isPlaying", "Is the clip playing right now (Read Only)?" },
{ "AudioSource-loop", "Is the audio clip looping?" },
{ "AudioSource-maxDistance", "(Logarithmic rolloff) MaxDistance is the distance a sound stops attenuating at." },
{ "AudioSource-minDistance", "Within the Min distance the AudioSource will cease to grow louder in volume." },
{ "AudioSource-mute", "Un- / Mutes the AudioSource. Mute sets the volume=0, Un-Mute restore the original volume." },
{ "AudioSource-pan", "Sets a channels pan position linearly. Only works for 2D clips." },
{ "AudioSource-panLevel", "Sets how much the 3d engine has an effect on the channel." },
{ "AudioSource-pitch", "The pitch of the audio source." },
{ "AudioSource-playOnAwake", "If set to true, the audio source will automatically start playing on awake." },
{ "AudioSource-priority", "Sets the priority of the AudioSource." },
{ "AudioSource-rolloffMode", "Sets/Gets how the AudioSource attenuates over distance." },
{ "AudioSource-spread", "Sets the spread angle a 3d stereo or multichannel sound in speaker space." },
{ "AudioSource-time", "Playback position in seconds." },
{ "AudioSource-timeSamples", "Playback position in PCM samples." },
{ "AudioSource-velocityUpdateMode", "Whether the Audio Source should be updated in the fixed or dynamic update." },
{ "AudioSource-volume", "The volume of the audio source (0.0 to 1.0)." },
{ "AudioSource.GetOutputData", "Returns a block of the currently playing source's output data." },
{ "AudioSource.GetSpectrumData", "Returns a block of the currently playing source's spectrum data." },
{ "AudioSource.Pause", "Pauses playing the clip." },
{ "AudioSource.Play", "Plays the clip with an optional certain delay." },
{ "AudioSource.PlayClipAtPoint", "Plays an AudioClip at a given position in world space." },
{ "AudioSource.PlayDelayed", "Plays the clip with a delay specified in seconds. Users are advised to use this function instead of the old Play(delay) function that took a delay specified in samples relative to a reference rate of 44.1 kHz as an argument." },
{ "AudioSource.PlayOneShot", "Plays an AudioClip, and scales the AudioSource volume by volumeScale." },
{ "AudioSource.PlayScheduled", "Plays the clip at a specific time on the absolute time-line that AudioSettings.dspTime reads from." },
{ "AudioSource.SetScheduledEndTime", "Changes the time at which a sound that has already been scheduled to play will end. Notice that depending on the timing not all rescheduling requests can be fulfilled." },
{ "AudioSource.SetScheduledStartTime", "Changes the time at which a sound that has already been scheduled to play will start." },
{ "AudioSource.Stop", "Stops playing the clip." },
{ "AudioSpeakerMode", "These are speaker types defined for use with AudioSettings.speakerMode." },
{ "AudioSpeakerMode.Mode5point1", "Channel count is set to 6. 5.1 speaker setup. This includes front left, front right, center, rear left, rear right and a subwoofer." },
{ "AudioSpeakerMode.Mode7point1", "Channel count is set to 8. 7.1 speaker setup. This includes front left, front right, center, rear left, rear right, side left, side right and a subwoofer." },
{ "AudioSpeakerMode.Mono", "Channel count is set to 1. The speakers are monaural." },
{ "AudioSpeakerMode.Prologic", "Channel count is set to 2. Stereo output, but data is encoded in a way that is picked up by a Prologic/Prologic2 decoder and split into a 5.1 speaker setup." },
{ "AudioSpeakerMode.Quad", "Channel count is set to 4. 4 speaker setup. This includes front left, front right, rear left, rear right." },
{ "AudioSpeakerMode.Raw", "Channel count is unaffected." },
{ "AudioSpeakerMode.Stereo", "Channel count is set to 2. The speakers are stereo. This is the editor default." },
{ "AudioSpeakerMode.Surround", "Channel count is set to 5. 5 speaker setup. This includes front left, front right, center, rear left, rear right." },
{ "AudioType", "Type of the imported(native) data." },
{ "AudioType.ACC", "Acc - not supported." },
{ "AudioType.AIFF", "Aiff." },
{ "AudioType.AUDIOQUEUE", "iPhone hardware decoder, supports AAC, ALAC and MP3. Extracodecdata is a pointer to an FMOD_AUDIOQUEUE_EXTRACODECDATA structure." },
{ "AudioType.IT", "Impulse tracker." },
{ "AudioType.MOD", "Protracker / Fasttracker MOD." },
{ "AudioType.MPEG", "MP2/MP3 MPEG." },
{ "AudioType.OGGVORBIS", "Ogg vorbis." },
{ "AudioType.S3M", "ScreamTracker 3." },
{ "AudioType.UNKNOWN", "3rd party / unknown plugin format." },
{ "AudioType.VAG", "VAG." },
{ "AudioType.WAV", "Microsoft WAV." },
{ "AudioType.XM", "FastTracker 2 XM." },
{ "AudioType.XMA", "Xbox360 XMA." },
{ "AudioVelocityUpdateMode", "Describes when an AudioSource or AudioListener is updated." },
{ "AudioVelocityUpdateMode.Auto", "Updates the source or listener in the fixed update loop if it is attached to a Rigidbody, dynamic otherwise." },
{ "AudioVelocityUpdateMode.Dynamic", "Updates the source or listener in the dynamic update loop." },
{ "AudioVelocityUpdateMode.Fixed", "Updates the source or listener in the fixed update loop." },
{ "Avatar", "Avatar definition." },
{ "Avatar-isHuman", "Return true if this avatar is a valid human avatar." },
{ "Avatar-isValid", "Return true if this avatar is a valid mecanim avatar. It can be a generic avatar or a human avatar." },
{ "AvatarBuilder", "Class to build avatars from user scripts." },
{ "AvatarBuilder.BuildGenericAvatar", "Create a new generic avatar." },
{ "AvatarBuilder.BuildHumanAvatar", "Create a humanoid avatar." },
{ "AvatarIKGoal", "IK Goal." },
{ "AvatarIKGoal.LeftFoot", "The left foot." },
{ "AvatarIKGoal.LeftHand", "The left hand." },
{ "AvatarIKGoal.RightFoot", "The right foot." },
{ "AvatarIKGoal.RightHand", "The right hand." },
{ "AvatarTarget", "Target." },
{ "AvatarTarget.Body", "The body, center of mass." },
{ "AvatarTarget.LeftFoot", "The left foot." },
{ "AvatarTarget.LeftHand", "The left hand." },
{ "AvatarTarget.RightFoot", "The right foot." },
{ "AvatarTarget.RightHand", "The right hand." },
{ "AvatarTarget.Root", "The root, the position of the game object." },
{ "BaseHierarchySort", "The base class used to create new sorting." },
{ "BaseHierarchySort-content", "The content to display to quickly identify the hierarchy's mode." },
{ "BaseHierarchySort.Compare", "The sorting method used to determine the order of GameObjects." },
{ "Behaviour", "Behaviours are Components that can be enabled or disabled." },
{ "Behaviour-enabled", "Enabled Behaviours are Updated, disabled Behaviours are not." },
{ "BitStream", "The BitStream class represents seralized variables, packed into a stream." },
{ "BitStream-isReading", "Is the BitStream currently being read? (Read Only)" },
{ "BitStream-isWriting", "Is the BitStream currently being written? (Read Only)" },
{ "BitStream.Serialize", "Serializes different types of variables." },
{ "BlackBerryBuildSubtarget", "Texture Compression Types." },
{ "BlackBerryBuildSubtarget.ATC", "ATI texture compression. Available on BlackBerry devices running Adreno GPU." },
{ "BlackBerryBuildSubtarget.ETC", "ETC1 texture compression (or RGBA16 for textures with alpha), supported by all devices." },
{ "BlackBerryBuildSubtarget.Generic", "Don't override texture compression." },
{ "BlackBerryBuildSubtarget.PVRTC", "PowerVR texture compression. Available on BlackBerry devices running PowerVR GPU's." },
{ "BlackBerryBuildType", "Build types available for BlackBerry." },
{ "BlackBerryBuildType.Debug", "Build type for local testing purposes." },
{ "BlackBerryBuildType.Submission", "Signed build used for submission to BlackBerry AppWorld." },
{ "BlendWeights", "Blend weights." },
{ "BlendWeights.FourBones", "Four bones affect each vertex." },
{ "BlendWeights.OneBone", "One bone affects each vertex." },
{ "BlendWeights.TwoBones", "Two bones affect each vertex." },
{ "BoneWeight", "Skinning bone weights of a vertex in the mesh." },
{ "BoneWeight-boneIndex0", "Index of first bone." },
{ "BoneWeight-boneIndex1", "Index of second bone." },
{ "BoneWeight-boneIndex2", "Index of third bone." },
{ "BoneWeight-boneIndex3", "Index of fourth bone." },
{ "BoneWeight-weight0", "Skinning weight for first bone." },
{ "BoneWeight-weight1", "Skinning weight for second bone." },
{ "BoneWeight-weight2", "Skinning weight for third bone." },
{ "BoneWeight-weight3", "Skinning weight for fourth bone." },
{ "Bounds", "Represents an axis aligned bounding box." },
{ "Bounds-center", "The center of the bounding box." },
{ "Bounds-ctor", "Creates new Bounds with a given center and total size. Bound extents will be half the given size." },
{ "Bounds-extents", "The extents of the box. This is always half of the size." },
{ "Bounds-max", "The maximal point of the box. This is always equal to center+extents." },
{ "Bounds-min", "The minimal point of the box. This is always equal to center-extents." },
{ "Bounds-size", "The total size of the box. This is always twice as large as the extents." },
{ "Bounds.Contains", "Is point contained in the bounding box?" },
{ "Bounds.Encapsulate", "Grows the Bounds to include the point." },
{ "Bounds.Expand", "Expand the bounds by increasing its size by amount along each side." },
{ "Bounds.IntersectRay", "Does ray intersect this bounding box?" },
{ "Bounds.Intersects", "Does another bounding box intersect with this bounding box?" },
{ "Bounds.SetMinMax", "Sets the bounds to the min and max value of the box." },
{ "Bounds.SqrDistance", "The smallest squared distance between the point and this bounding box." },
{ "Bounds.ToString", "Returns a nicely formatted string for the bounds." },
{ "BoxCollider", "A box-shaped primitive collider." },
{ "BoxCollider-center", "The center of the box, measured in the object's local space." },
{ "BoxCollider-size", "The size of the box, measured in the object's local space." },
{ "BoxCollider2D", "Collider for 2D physics representing an axis-aligned rectangle." },
{ "BoxCollider2D-center", "The center point of the rectangle in local space." },
{ "BoxCollider2D-size", "The width and height of the rectangle." },
{ "BuildAssetBundleOptions", "Asset Bundle building options." },
{ "BuildAssetBundleOptions.CollectDependencies", "Includes all dependencies." },
{ "BuildAssetBundleOptions.CompleteAssets", "Forces inclusion of the entire asset." },
{ "BuildAssetBundleOptions.DeterministicAssetBundle", "Builds an asset bundle using a hash for the id of the object stored in the asset bundle." },
{ "BuildAssetBundleOptions.DisableWriteTypeTree", "Do not include type information within the AssetBundle." },
{ "BuildAssetBundleOptions.UncompressedAssetBundle", "Don't compress the data when creating the asset bundle." },
{ "BuildOptions", "Building options. Multiple options can be combined together." },
{ "BuildOptions.AcceptExternalModificationsToPlayer", "Used when building XCode (iPhone) or Eclipse (Android) projects." },
{ "BuildOptions.AllowDebugging", "Allow script debuggers to attach to the player remotely." },
{ "BuildOptions.AutoRunPlayer", "Run the built player." },
{ "BuildOptions.BuildAdditionalStreamedScenes", "Build a compressed asset bundle that contains streamed scenes loadable with the WWW class." },
{ "BuildOptions.ConnectWithProfiler", "Start the player with a connection to the profiler in the editor." },
{ "BuildOptions.DeployOnline", "Generate online version of webplayer." },
{ "BuildOptions.Development", "Build a development version of the player." },
{ "BuildOptions.None", "Perform the specified build without any special settings or extra tasks." },
{ "BuildOptions.ShowBuiltPlayer", "Show the built player." },
{ "BuildOptions.SymlinkLibraries", "Symlink runtime libraries when generating iOS XCode project. (Faster iteration time)." },
{ "BuildOptions.UncompressedAssetBundle", "Don't compress the data when creating the asset bundle." },
{ "BuildOptions.WebPlayerOfflineDeployment", "Copy UnityObject.js alongside Web Player so it wouldn't have to be downloaded from internet." },
{ "BuildPipeline", "Lets you programmatically build players or AssetBundles which can be loaded from the web." },
{ "BuildPipeline-isBuildingPlayer", "Is a player currently being built?" },
{ "BuildPipeline.BuildAssetBundle", "Builds an asset bundle (Unity Pro only)." },
{ "BuildPipeline.BuildAssetBundleExplicitAssetNames", "Builds an asset bundle, with custom names for the assets (Unity Pro only)." },
{ "BuildPipeline.BuildPlayer", "Builds a player (Unity Pro only)." },
{ "BuildPipeline.BuildStreamedSceneAssetBundle", "Builds one or more scenes and all their dependencies into a compressed asset bundle." },
{ "BuildPipeline.PopAssetDependencies", "Lets you manage cross-references and dependencies between different asset bundles and player builds." },
{ "BuildPipeline.PushAssetDependencies", "Lets you manage cross-references and dependencies between different asset bundles and player builds." },
{ "BuildTarget", "Target build platform." },
{ "BuildTarget-iPhone", "Build an iPhone player." },
{ "BuildTarget.Android", "Build an Android .apk standalone app." },
{ "BuildTarget.FlashPlayer", "Build content as an swf file for playback with Adobe Flash." },
{ "BuildTarget.PS3", "Build a PS3 Standalone." },
{ "BuildTarget.PS4", "Build a PS4 Standalone." },
{ "BuildTarget.PSM", "Build a PSM Standalone." },
{ "BuildTarget.PSP2", "Build a PS Vita Standalone." },
{ "BuildTarget.SamsungTV", "Build to Samsung Smart TV platform." },
{ "BuildTarget.StandaloneLinux", "Build a Linux standalone." },
{ "BuildTarget.StandaloneLinux64", "Build a Linux 64-bit standalone." },
{ "BuildTarget.StandaloneLinuxUniversal", "Build a Linux universal standalone." },
{ "BuildTarget.StandaloneOSXIntel", "Build an OS X standalone (Intel only)." },
{ "BuildTarget.StandaloneOSXIntel64", "Build an OSX Intel 64-bit standalone." },
{ "BuildTarget.StandaloneOSXUniversal", "Build a universal OSX standalone." },
{ "BuildTarget.StandaloneWindows", "Build a Windows standalone." },
{ "BuildTarget.StandaloneWindows64", "Build a Windows 64-bit standalone." },
{ "BuildTarget.Tizen", "Build a Tizen player." },
{ "BuildTarget.WebPlayer", "Build a web player." },
{ "BuildTarget.WebPlayerStreamed", "Build a streamed web player." },
{ "BuildTarget.WP8Player", "Build a Windows Phone 8 player." },
{ "BuildTarget.XBOX360", "Build a XBox Standalone." },
{ "BuildTarget.XboxOne", "Build a Xbox One Standalone." },
{ "BuildTargetGroup", "Build target group." },
{ "BuildTargetGroup-iPhone", "Apple iOS target." },
{ "BuildTargetGroup.Android", "Android target." },
{ "BuildTargetGroup.FlashPlayer", "Flash player target." },
{ "BuildTargetGroup.GLESEmu", "GLESEmu target." },
{ "BuildTargetGroup.PS3", "Sony Playstation 3 target." },
{ "BuildTargetGroup.PS4", "Sony Playstation 4 target." },
{ "BuildTargetGroup.PSM", "Sony Playstation Mobile target." },
{ "BuildTargetGroup.PSP2", "Sony PS Vita target." },
{ "BuildTargetGroup.SamsungTV", "Samsung Smart TV target." },
{ "BuildTargetGroup.Standalone", "Mac/PC standalone target." },
{ "BuildTargetGroup.Tizen", "Samsung Tizen target." },
{ "BuildTargetGroup.Unknown", "Unknown target." },
{ "BuildTargetGroup.WebPlayer", "Mac/PC webplayer target." },
{ "BuildTargetGroup.WP8", "Windows Phone 8 target." },
{ "BuildTargetGroup.XBOX360", "Microsoft XBOX360 target." },
{ "BuildTargetGroup.XboxOne", "Microsoft Xbox One target." },
{ "Caching", "The Caching class lets you manage cached AssetBundles, downloaded using WWW.LoadFromCacheOrDownload." },
{ "Caching-enabled", "Is Caching enabled?" },
{ "Caching-expirationDelay", "The number of seconds that an AssetBundle may remain unused in the cache before it is automatically deleted." },
{ "Caching-maximumAvailableDiskSpace", "The total number of bytes that can potentially be allocated for caching." },
{ "Caching-ready", "Is caching ready?" },
{ "Caching-spaceFree", "The number of currently unused bytes in the cache." },
{ "Caching-spaceOccupied", "Used disk space in bytes." },
{ "Caching.Authorize", "(This is a WebPlayer-only function)." },
{ "Caching.CleanCache", "Delete all AssetBundle content that has been cached by the current application." },
{ "Caching.IsVersionCached", "Checks if an AssetBundle is cached." },
{ "Caching.MarkAsUsed", "Bumps the timestamp of a cached file to be the current time." },
{ "CalendarIdentifier", "Specify calendar types." },
{ "CalendarIdentifier.BuddhistCalendar", "Identifies the Buddhist calendar." },
{ "CalendarIdentifier.ChineseCalendar", "Identifies the Chinese calendar." },
{ "CalendarIdentifier.GregorianCalendar", "Identifies the Gregorian calendar." },
{ "CalendarIdentifier.HebrewCalendar", "Identifies the Hebrew calendar." },
{ "CalendarIdentifier.IndianCalendar", "Identifies the Indian calendar." },
{ "CalendarIdentifier.IslamicCalendar", "Identifies the Islamic calendar." },
{ "CalendarIdentifier.IslamicCivilCalendar", "Identifies the Islamic civil calendar." },
{ "CalendarIdentifier.ISO8601Calendar", "Identifies the ISO8601." },
{ "CalendarIdentifier.JapaneseCalendar", "Identifies the Japanese calendar." },
{ "CalendarIdentifier.PersianCalendar", "Identifies the Persian calendar." },
{ "CalendarIdentifier.RepublicOfChinaCalendar", "Identifies the Republic of China (Taiwan) calendar." },
{ "CalendarUnit", "Specify calendrical units." },
{ "CalendarUnit.Day", "Specifies the day unit." },
{ "CalendarUnit.Era", "Specifies the era unit." },
{ "CalendarUnit.Hour", "Specifies the hour unit." },
{ "CalendarUnit.Minute", "Specifies the minute unit." },
{ "CalendarUnit.Month", "Specifies the month unit." },
{ "CalendarUnit.Quarter", "Specifies the quarter of the calendar." },
{ "CalendarUnit.Second", "Specifies the second unit." },
{ "CalendarUnit.Week", "Specifies the week unit." },
{ "CalendarUnit.Weekday", "Specifies the weekday unit." },
{ "CalendarUnit.WeekdayOrdinal", "Specifies the ordinal weekday unit." },
{ "CalendarUnit.Year", "Specifies the year unit." },
{ "CallbackOrderAttribute", "Smaller m_CallbackOrder values will be called first." },
{ "Callbacks.DidReloadScripts", "Add this attribute to a method to get a notification after scripts have been reloaded." },
{ "Callbacks.DidReloadScripts-ctor", "DidReloadScripts attribute." },
{ "Callbacks.OnOpenAssetAttribute", "Callback attribute for opening an asset in Unity (e.g the callback is fired when double clicking an asset in the Project Browser)." },
{ "Callbacks.PostProcessBuildAttribute", "Add this attribute to a method to get a notification just after building the player." },
{ "Callbacks.PostProcessSceneAttribute", "Add this attribute to a method to get a notification just before building the scene." },
{ "Camera", "A Camera is a device through which the player views the world." },
{ "Camera-actualRenderingPath", "Actually used rendering path (Read Only)." },
{ "Camera-allCameras", "Returns all enabled cameras in the scene." },
{ "Camera-allCamerasCount", "The number of cameras in the current scene." },
{ "Camera-aspect", "The aspect ratio (width divided by height)." },
{ "Camera-backgroundColor", "The color with which the screen will be cleared." },
{ "Camera-cameraToWorldMatrix", "Matrix that transforms from camera space to world space (Read Only)." },
{ "Camera-clearFlags", "How the camera clears the background." },
{ "Camera-cullingMask", "This is used to render parts of the scene selectively." },
{ "Camera-current", "The camera we are currently rendering with, for low-level render control only (Read Only)." },
{ "Camera-depth", "Camera's depth in the camera rendering order." },
{ "Camera-depthTextureMode", "How and if camera generates a depth texture." },
{ "Camera-eventMask", "Mask to select which layers can trigger events on the camera." },
{ "Camera-farClipPlane", "The far clipping plane distance." },
{ "Camera-fieldOfView", "The field of view of the camera in degrees." },
{ "Camera-hdr", "High dynamic range rendering." },
{ "Camera-layerCullDistances", "Per-layer culling distances." },
{ "Camera-layerCullSpherical", "How to perform per-layer culling for a Camera." },
{ "Camera-main", "The first enabled camera tagged \"MainCamera\" (Read Only)." },
{ "Camera-nearClipPlane", "The near clipping plane distance." },
{ "Camera-orthographic", "Is the camera orthographic (true) or perspective (false)?" },
{ "Camera-orthographicSize", "Camera's half-size when in orthographic mode." },
{ "Camera-pixelHeight", "How tall is the camera in pixels (Read Only)." },
{ "Camera-pixelRect", "Where on the screen is the camera rendered in pixel coordinates." },
{ "Camera-pixelWidth", "How wide is the camera in pixels (Read Only)." },
{ "Camera-projectionMatrix", "Set a custom projection matrix." },
{ "Camera-rect", "Where on the screen is the camera rendered in normalized coordinates." },
{ "Camera-renderingPath", "Rendering path." },
{ "Camera-stereoConvergence", "Distance to a point where virtual eyes converge." },
{ "Camera-stereoEnabled", "Stereoscopic rendering." },
{ "Camera-stereoSeparation", "Distance between the virtual eyes." },
{ "Camera-targetTexture", "Destination render texture (Unity Pro only)." },
{ "Camera-transparencySortMode", "Transparent object sorting mode." },
{ "Camera-useOcclusionCulling", "Whether or not the Camera will use occlusion culling during rendering." },
{ "Camera-velocity", "Get the world-space speed of the camera (Read Only)." },
{ "Camera-worldToCameraMatrix", "Matrix that transforms from world to camera space." },
{ "Camera.CalculateObliqueMatrix", "Calculates and returns oblique near-plane projection matrix." },
{ "Camera.CopyFrom", "Makes this camera's settings match other camera." },
{ "Camera.GetAllCameras", "Fills an array of Camera with the current cameras in the scene, without allocating a new array." },
{ "Camera.OnPostRender", "OnPostRender is called after a camera has finished rendering the scene." },
{ "Camera.OnPreCull", "OnPreCull is called before a camera culls the scene." },
{ "Camera.OnPreRender", "OnPreRender is called before a camera starts rendering the scene." },
{ "Camera.OnRenderImage", "OnRenderImage is called after all rendering is complete to render image." },
{ "Camera.OnRenderObject", "OnRenderObject is called after camera has rendered the scene." },
{ "Camera.OnWillRenderObject", "OnWillRenderObject is called once for each camera if the object is visible." },
{ "Camera.Render", "Render the camera manually." },
{ "Camera.RenderToCubemap", "Render into a static cubemap from this camera." },
{ "Camera.RenderWithShader", "Render the camera with shader replacement." },
{ "Camera.ResetAspect", "Revert the aspect ratio to the screen's aspect ratio." },
{ "Camera.ResetProjectionMatrix", "Make the projection reflect normal camera's parameters." },
{ "Camera.ResetReplacementShader", "Remove shader replacement from camera." },
{ "Camera.ResetWorldToCameraMatrix", "Make the rendering position reflect the camera's position in the scene." },
{ "Camera.ScreenPointToRay", "Returns a ray going from camera through a screen point." },
{ "Camera.ScreenToViewportPoint", "Transforms position from screen space into viewport space." },
{ "Camera.ScreenToWorldPoint", "Transforms position from screen space into world space." },
{ "Camera.SetReplacementShader", "Make the camera render with shader replacement." },
{ "Camera.SetTargetBuffers", "Sets the Camera to render to the chosen buffers of one or more RenderTextures." },
{ "Camera.ViewportPointToRay", "Returns a ray going from camera through a viewport point." },
{ "Camera.ViewportToScreenPoint", "Transforms position from viewport space into screen space." },
{ "Camera.ViewportToWorldPoint", "Transforms position from viewport space into world space." },
{ "Camera.WorldToScreenPoint", "Transforms position from world space into screen space." },
{ "Camera.WorldToViewportPoint", "Transforms position from world space into viewport space." },
{ "CameraClearFlags", "Values for Camera.clearFlags, determining what to clear when rendering a Camera." },
{ "CameraClearFlags.Depth", "Clear only the depth buffer." },
{ "CameraClearFlags.Nothing", "Don't clear anything." },
{ "CameraClearFlags.Skybox", "Clear with the skybox." },
{ "CameraClearFlags.SolidColor", "Clear with a background color." },
{ "CanEditMultipleObjects", "Attribute used to make a custom editor support multi-object editing." },
{ "CapsuleCollider", "A capsule-shaped primitive collider." },
{ "CapsuleCollider-center", "The center of the capsule, measured in the object's local space." },
{ "CapsuleCollider-direction", "The direction of the capsule." },
{ "CapsuleCollider-height", "The height of the capsule meased in the object's local space." },
{ "CapsuleCollider-radius", "The radius of the sphere, measured in the object's local space." },
{ "CharacterController", "A CharacterController allows you to easily do movement constrained by collisions without having to deal with a rigidbody." },
{ "CharacterController-center", "The center of the character's capsule relative to the transform's position." },
{ "CharacterController-collisionFlags", "What part of the capsule collided with the environment during the last CharacterController.Move call." },
{ "CharacterController-detectCollisions", "Determines whether other rigidbodies or character controllers collide with this character controller (by default this is always enabled)." },
{ "CharacterController-height", "The height of the character's capsule." },
{ "CharacterController-isGrounded", "Was the CharacterController touching the ground during the last move?" },
{ "CharacterController-radius", "The radius of the character's capsule." },
{ "CharacterController-slopeLimit", "The character controllers slope limit in degrees." },
{ "CharacterController-stepOffset", "The character controllers step offset in meters." },
{ "CharacterController-velocity", "The current relative velocity of the Character (see notes)." },
{ "CharacterController.Move", "A more complex move function taking absolute movement deltas." },
{ "CharacterController.OnControllerColliderHit", "OnControllerColliderHit is called when the controller hits a collider while performing a Move." },
{ "CharacterController.SimpleMove", "Moves the character with speed." },
{ "CharacterInfo", "Info how to render a character from the font texture. See /Font.characterInfo/." },
{ "CharacterInfo-flipped", "Is the character flipped?" },
{ "CharacterInfo-index", "Unicode value of the character." },
{ "CharacterInfo-size", "The size of the character or 0 if it is the default font size." },
{ "CharacterInfo-style", "The style of the character." },
{ "CharacterInfo-uv", "UV coordinates for the character in the texture." },
{ "CharacterInfo-vert", "Screen coordinates for the character in generated text meshes." },
{ "CharacterInfo-width", "How for to advance between the beginning of this charcater and the next." },
{ "CharacterJoint", "Character Joints are mainly used for Ragdoll effects. They are an extended ball-socket joint which allows you to limit the joint on each axis." },
{ "CharacterJoint-highTwistLimit", "The upper limit around the primary axis of the character joint." },
{ "CharacterJoint-lowTwistLimit", "The lower limit around the primary axis of the character joint." },
{ "CharacterJoint-swing1Limit", "The limit around the primary axis of the character joint." },
{ "CharacterJoint-swing2Limit", "The limit around the primary axis of the character joint." },
{ "CharacterJoint-swingAxis", "The secondary axis around which the joint can rotate." },
{ "CircleCollider2D", "Collider for 2D physics representing an circle." },
{ "CircleCollider2D-center", "Center point of the circle in local space." },
{ "CircleCollider2D-radius", "Radius of the circle." },
{ "ClipAnimationMaskType", "AnimationClip mask options for ModelImporterClipAnimation." },
{ "ClipAnimationMaskType.CopyFromOther", "Use a mask from your project to specify which transforms animation should be imported." },
{ "ClipAnimationMaskType.CreateFromThisModel", "A mask containing all the transform in the file will be created internally." },
{ "Cloth", "Base class used to simulate cloth physics - shared by both InteractiveCloth and SkinnedCloth." },
{ "Cloth-bendingStiffness", "Bending stiffness of the cloth." },
{ "Cloth-damping", "Damp cloth motion." },
{ "Cloth-enabled", "Is this cloth enabled?" },
{ "Cloth-externalAcceleration", "A constant, external acceleration applied to the cloth." },
{ "Cloth-normals", "The current normals of the cloth object." },
{ "Cloth-randomAcceleration", "A random, external acceleration applied to the cloth." },
{ "Cloth-selfCollision", "Will the cloth collide with itself?" },
{ "Cloth-stretchingStiffness", "Stretching stiffness of the cloth." },
{ "Cloth-thickness", "The thickness of the cloth surface." },
{ "Cloth-useGravity", "Should gravity affect the cloth simulation?" },
{ "Cloth-vertices", "The current vertex positions of the cloth object." },
{ "ClothRenderer", "The ClothRenderer component is used together with the InteractiveCloth component, to visualize a cloth object in the scene." },
{ "ClothRenderer-pauseWhenNotVisible", "Should the cloth simulation be paused when the ClothRenderer is not visible?" },
{ "ClothSkinningCoefficient", "The ClothSkinningCoefficient struct is used to set up how a SkinnedCloth component is allowed to move with respect to the SkinnedMeshRenderer it is attached to." },
{ "ClothSkinningCoefficient-collisionSphereDistance", "Definition of a sphere a vertex is not allowed to enter. This allows collision against the animated cloth." },
{ "ClothSkinningCoefficient-collisionSphereRadius", "Definition of a sphere a vertex is not allowed to enter. This allows collision against the animated cloth." },
{ "ClothSkinningCoefficient-maxDistance", "Distance a vertex is allowed to travel from the skinned mesh vertex position." },
{ "ClothSkinningCoefficient-maxDistanceBias", "Distorts the sphere defined by the maxDistance based on skinned mesh normals." },
{ "Collider", "A base class of all colliders." },
{ "Collider-attachedRigidbody", "The rigidbody the collider is attached to." },
{ "Collider-bounds", "The world space bounding volume of the collider." },
{ "Collider-enabled", "Enabled Colliders will collide with other colliders, disabled Colliders won't." },
{ "Collider-isTrigger", "Is the collider a trigger?" },
{ "Collider-material", "The material used by the collider." },
{ "Collider-sharedMaterial", "The shared physic material of this collider." },
{ "Collider.ClosestPointOnBounds", "The closest point to the bounding box of the attached collider." },
{ "Collider.OnCollisionEnter", "OnCollisionEnter is called when this collider/rigidbody has begun touching another rigidbody/collider." },
{ "Collider.OnCollisionExit", "OnCollisionExit is called when this collider/rigidbody has stopped touching another rigidbody/collider." },
{ "Collider.OnCollisionStay", "OnCollisionStay is called once per frame for every collider/rigidbody that is touching rigidbody/collider." },
{ "Collider.OnTriggerEnter", "OnTriggerEnter is called when the Collider other enters the trigger." },
{ "Collider.OnTriggerExit", "OnTriggerExit is called when the Collider other has stopped touching the trigger." },
{ "Collider.OnTriggerStay", "OnTriggerStay is called almost all the frames for every Collider other that is touching the trigger." },
{ "Collider.Raycast", "Casts a Ray that ignores all Colliders except this one." },
{ "Collider2D", "Parent class for collider types used with 2D gameplay." },
{ "Collider2D-attachedRigidbody", "The Rigidbody2D attached to the Collider2D's GameObject." },
{ "Collider2D-bounds", "The world space bounding area of the collider." },
{ "Collider2D-isTrigger", "Is this collider configured as a trigger?" },
{ "Collider2D-shapeCount", "The number of separate shaped regions in the collider." },
{ "Collider2D-sharedMaterial", "The PhysicsMaterial2D that is applied to this collider." },
{ "Collider2D.OnCollisionEnter2D", "Sent when an incoming collider makes contact with this object's collider (2D physics only)." },
{ "Collider2D.OnCollisionExit2D", "Sent when a collider on another object stops touching this object's collider (2D physics only)." },
{ "Collider2D.OnCollisionStay2D", "Sent each frame where a collider on another object is touching this object's collider (2D physics only)." },
{ "Collider2D.OnTriggerEnter2D", "Sent when another object enters a trigger collider attached to this object (2D physics only)." },
{ "Collider2D.OnTriggerExit2D", "Sent when another object leaves a trigger collider attached to this object (2D physics only)." },
{ "Collider2D.OnTriggerStay2D", "Sent each frame where another object is within a trigger collider attached to this object (2D physics only)." },
{ "Collider2D.OverlapPoint", "Check if a collider overlaps a point in space." },
{ "Collision", "Describes collision." },
{ "Collision-collider", "The Collider we hit (Read Only)." },
{ "Collision-contacts", "The contact points generated by the physics engine." },
{ "Collision-gameObject", "The GameObject whose collider we are colliding with. (Read Only)." },
{ "Collision-relativeVelocity", "The relative linear velocity of the two colliding objects (Read Only)." },
{ "Collision-rigidbody", "The Rigidbody we hit (Read Only). This is null if the object we hit is a collider with no rigidbody attached." },
{ "Collision-transform", "The Transform of the object we hit (Read Only)." },
{ "Collision2D", "Information returned by a collision in 2D physics." },
{ "Collision2D-collider", "The incoming Collider2D involved in the collision." },
{ "Collision2D-contacts", "The specific points of contact with the incoming Collider2D." },
{ "Collision2D-gameObject", "The incoming GameObject involved in the collision." },
{ "Collision2D-relativeVelocity", "The relative linear velocity of the two colliding objects (Read Only)." },
{ "Collision2D-rigidbody", "The incoming Rigidbody2D involved in the collision." },
{ "Collision2D-transform", "The Transform of the incoming object involved in the collision." },
{ "CollisionDetectionMode", "The collision detection mode constants used for Rigidbody.collisionDetectionMode." },
{ "CollisionDetectionMode.Continuous", "Continuous collision detection is on for colliding with static mesh geometry." },
{ "CollisionDetectionMode.ContinuousDynamic", "Continuous collision detection is on for colliding with static and dynamic geometry." },
{ "CollisionDetectionMode.Discrete", "Continuous collision detection is off for this Rigidbody." },
{ "CollisionDetectionMode2D", "Options for the detection mode used by a Rigidbody2D." },
{ "CollisionDetectionMode2D.Continuous", "The Rigidbody2D estimates its position between physics updates." },
{ "CollisionDetectionMode2D.None", "No collision detection is used on the Rigidbody2D." },
{ "CollisionFlags", "CollisionFlags is a bitmask returned by CharacterController.Move." },
{ "CollisionFlags.Above", "CollisionFlags is a bitmask returned by CharacterController.Move." },
{ "CollisionFlags.Below", "CollisionFlags is a bitmask returned by CharacterController.Move." },
{ "CollisionFlags.None", "CollisionFlags is a bitmask returned by CharacterController.Move." },
{ "CollisionFlags.Sides", "CollisionFlags is a bitmask returned by CharacterController.Move." },
{ "Color", "Representation of RGBA colors." },
{ "Color-a", "Alpha component of the color." },
{ "Color-b", "Blue component of the color." },
{ "Color-black", "Solid black. RGBA is (0, 0, 0, 1)." },
{ "Color-blue", "Solid blue. RGBA is (0, 0, 1, 1)." },
{ "Color-clear", "Completely transparent. RGBA is (0, 0, 0, 0)." },
{ "Color-ctor", "Constructs a new Color with given r,g,b,a components." },
{ "Color-cyan", "Cyan. RGBA is (0, 1, 1, 1)." },
{ "Color-g", "Green component of the color." },
{ "Color-gamma", "A version of the color that has had the gamma curve applied." },
{ "Color-gray", "Gray. RGBA is (0.5, 0.5, 0.5, 1)." },
{ "Color-grayscale", "The grayscale value of the color. (Read Only)" },
{ "Color-green", "Solid green. RGBA is (0, 1, 0, 1)." },
{ "Color-grey", "English spelling for gray. RGBA is the same (0.5, 0.5, 0.5, 1)." },
{ "Color-linear", "A version of the color that has had the inverse gamma curve applied." },
{ "Color-magenta", "Magenta. RGBA is (1, 0, 1, 1)." },
{ "Color-operator_add", "Adds two colors together. Each component is added separately." },
{ "Color-operator_Color", "Colors can be implicitly converted to and from Vector4." },
{ "Color-operator_divide", "Divides color a by the float b. Each color component is scaled separately." },
{ "Color-operator_multiply", "Multiplies two colors together. Each component is multiplied separately." },
{ "Color-operator_subtract", "Subtracts color b from color a. Each component is subtracted separately." },
{ "Color-operator_Vector4", "Colors can be implicitly converted to and from Vector4." },
{ "Color-r", "Red component of the color." },
{ "Color-red", "Solid red. RGBA is (1, 0, 0, 1)." },
{ "Color-white", "Solid white. RGBA is (1, 1, 1, 1)." },
{ "Color-yellow", "Yellow. RGBA is (1, 0.92, 0.016, 1), but the color is nice to look at!" },
{ "Color.Index_operator", "Access the r, g, b,a components using [0], [1], [2], [3] respectively." },
{ "Color.Lerp", "Interpolates between colors a and b by t." },
{ "Color.ToString", "Returns a nicely formatted string of this color." },
{ "Color32", "Representation of RGBA colors in 32 bit format." },
{ "Color32-a", "Alpha component of the color." },
{ "Color32-b", "Blue component of the color." },
{ "Color32-ctor", "Constructs a new Color with given r, g, b, a components." },
{ "Color32-g", "Green component of the color." },
{ "Color32-operator_Color", "Color32 can be implicitly converted to and from Color." },
{ "Color32-operator_Color32", "Color32 can be implicitly converted to and from Color." },
{ "Color32-r", "Red component of the color." },
{ "Color32.Lerp", "Interpolates between colors a and b by t." },
{ "Color32.ToString", "Returns a nicely formatted string of this color." },
{ "ColorSpace", "Valid color spaces." },
{ "ColorSpace.Gamma", "Lightmap has been baked for gamma rendering." },
{ "ColorSpace.Linear", "Lightmap has been baked for linear rendering." },
{ "ColorSpace.Uninitialized", "Uninitialized colorspace." },
{ "CombineInstance", "Struct used to describe meshes to be combined using Mesh.CombineMeshes." },
{ "CombineInstance-mesh", "Mesh to combine." },
{ "CombineInstance-subMeshIndex", "Submesh index of the mesh." },
{ "CombineInstance-transform", "Matrix to transform the mesh with before combining." },
{ "Compass", "Interface into compass functionality." },
{ "Compass-enabled", "Used to enable or disable compass. Note, that if you want Input.compass.trueHeading property to contain a valid value, you must also enable location updates by calling Input.location.Start()." },
{ "Compass-headingAccuracy", "Accuracy of heading reading in degrees." },
{ "Compass-magneticHeading", "The heading in degrees relative to the magnetic North Pole. (Read Only)" },
{ "Compass-rawVector", "The raw geomagnetic data measured in microteslas. (Read Only)" },
{ "Compass-timestamp", "Timestamp (in seconds since 1970) when the heading was last time updated. (Read Only)" },
{ "Compass-trueHeading", "The heading in degrees relative to the geographic North Pole. (Read Only)" },
{ "Component", "Base class for everything attached to GameObjects." },
{ "Component-animation", "The Animation attached to this GameObject (null if there is none attached)." },
{ "Component-audio", "The AudioSource attached to this GameObject (null if there is none attached)." },
{ "Component-camera", "The Camera attached to this GameObject (null if there is none attached)." },
{ "Component-collider", "The Collider attached to this GameObject (null if there is none attached)." },
{ "Component-collider2D", "The Collider2D component attached to the object." },
{ "Component-constantForce", "The ConstantForce attached to this GameObject (null if there is none attached)." },
{ "Component-gameObject", "The game object this component is attached to. A component is always attached to a game object." },
{ "Component-guiText", "The GUIText attached to this GameObject (null if there is none attached)." },
{ "Component-guiTexture", "The GUITexture attached to this GameObject (Read Only). (null if there is none attached)." },
{ "Component-hingeJoint", "The HingeJoint attached to this GameObject (null if there is none attached)." },
{ "Component-light", "The Light attached to this GameObject (null if there is none attached)." },
{ "Component-networkView", "The NetworkView attached to this GameObject (Read Only). (null if there is none attached)." },
{ "Component-particleEmitter", "The ParticleEmitter attached to this GameObject (null if there is none attached)." },
{ "Component-particleSystem", "The ParticleSystem attached to this GameObject (null if there is none attached)." },
{ "Component-renderer", "The Renderer attached to this GameObject (null if there is none attached)." },
{ "Component-rigidbody", "The Rigidbody attached to this GameObject (null if there is none attached)." },
{ "Component-rigidbody2D", "The Rigidbody2D that is attached to the Component's GameObject." },
{ "Component-tag", "The tag of this game object." },
{ "Component-transform", "The Transform attached to this GameObject (null if there is none attached)." },
{ "Component.BroadcastMessage", "Calls the method named methodName on every MonoBehaviour in this game object or any of its children." },
{ "Component.CompareTag", "Is this game object tagged with /tag/?" },
{ "Component.GetComponent", "Returns the component of Type type if the game object has one attached, null if it doesn't." },
{ "Component.GetComponentInChildren", "Returns the component of Type type in the GameObject or any of its children using depth first search." },
{ "Component.GetComponentInParent", "Returns the component of Type type in the GameObject or any of its parents." },
{ "Component.GetComponents", "Returns all components of Type type in the GameObject." },
{ "Component.GetComponentsInChildren", "Returns all components of Type type in the GameObject or any of its children." },
{ "Component.GetComponentsInParent", "Returns all components of Type type in the GameObject or any of its parents." },
{ "Component.SendMessage", "Calls the method named methodName on every MonoBehaviour in this game object." },
{ "Component.SendMessageUpwards", "Calls the method named methodName on every MonoBehaviour in this game object and on every ancestor of the behaviour." },
{ "ComputeBuffer", "Data buffer to hold data for compute shaders." },
{ "ComputeBuffer-count", "Number of elements in the buffer (Read Only)." },
{ "ComputeBuffer-ctor", "Create a Compute Buffer." },
{ "ComputeBuffer-stride", "Size of one element in the buffer (Read Only)." },
{ "ComputeBuffer.CopyCount", "Set buffer data." },
{ "ComputeBuffer.GetData", "Read data values from the buffer into an array." },
{ "ComputeBuffer.Release", "Release a Compute Buffer." },
{ "ComputeBuffer.SetData", "Set the buffer with values from an array." },
{ "ComputeBufferType", "ComputeBuffer type." },
{ "ComputeBufferType.Append", "Append-consume ComputeBuffer type." },
{ "ComputeBufferType.Counter", "ComputeBuffer with a counter." },
{ "ComputeBufferType.Default", "Default ComputeBuffer type." },
{ "ComputeBufferType.DrawIndirect", "ComputeBuffer used for Graphics.DrawProceduralIndirect." },
{ "ComputeBufferType.Raw", "Raw ComputeBuffer type." },
{ "ComputeShader", "Compute Shader asset." },
{ "ComputeShader.Dispatch", "Execute a compute shader." },
{ "ComputeShader.FindKernel", "Find ComputeShader kernel index." },
{ "ComputeShader.SetBuffer", "This function can either set an input or output compute buffer." },
{ "ComputeShader.SetFloat", "Set a float parameter." },
{ "ComputeShader.SetFloats", "Set multiple consecutive float parameters at once." },
{ "ComputeShader.SetInt", "Set an integer parameter." },
{ "ComputeShader.SetInts", "Set multiple consecutive integer parameters at once." },
{ "ComputeShader.SetTexture", "Set a texture parameter." },
{ "ComputeShader.SetVector", "Set a vector parameter." },
{ "ConfigurableJoint", "The configurable joint is an extremely flexible joint giving you complete control over rotation and linear motion." },
{ "ConfigurableJoint-angularXDrive", "Definition of how the joint's rotation will behave around its local X axis. Only used if Rotation Drive Mode is Swing & Twist." },
{ "ConfigurableJoint-angularXMotion", "Allow rotation around the X axis to be Free, completely Locked, or Limited according to Low and High Angular XLimit." },
{ "ConfigurableJoint-angularYLimit", "Boundary defining rotation restriction, based on delta from original rotation." },
{ "ConfigurableJoint-angularYMotion", "Allow rotation around the Y axis to be Free, completely Locked, or Limited according to Angular YLimit." },
{ "ConfigurableJoint-angularYZDrive", "Definition of how the joint's rotation will behave around its local Y and Z axes. Only used if Rotation Drive Mode is Swing & Twist." },
{ "ConfigurableJoint-angularZLimit", "Boundary defining rotation restriction, based on delta from original rotation." },
{ "ConfigurableJoint-angularZMotion", "Allow rotation around the Z axis to be Free, completely Locked, or Limited according to Angular ZLimit." },
{ "ConfigurableJoint-configuredInWorldSpace", "If enabled, all Target values will be calculated in world space instead of the object's local space." },
{ "ConfigurableJoint-highAngularXLimit", "Boundary defining upper rotation restriction, based on delta from original rotation." },
{ "ConfigurableJoint-linearLimit", "Boundary defining movement restriction, based on distance from the joint's origin." },
{ "ConfigurableJoint-lowAngularXLimit", "Boundary defining lower rotation restriction, based on delta from original rotation." },
{ "ConfigurableJoint-projectionAngle", "Difference in angle from the Connected Body that must be exceeded before the object snaps back to an acceptable position." },
{ "ConfigurableJoint-projectionDistance", "Distance from the Connected Body that must be exceeded before the object snaps back to an acceptable position." },
{ "ConfigurableJoint-projectionMode", "Properties to track to snap the object back to its constrained position when it drifts off too much." },
{ "ConfigurableJoint-rotationDriveMode", "Control the object's rotation with either X & YZ or Slerp Drive by itself." },
{ "ConfigurableJoint-secondaryAxis", "The joint's secondary axis." },
{ "ConfigurableJoint-slerpDrive", "Definition of how the joint's rotation will behave around all local axes. Only used if Rotation Drive Mode is Slerp Only." },
{ "ConfigurableJoint-swapBodies", "If enabled, the two connected rigidbodies will be swapped, as if the joint was attached to the other body." },
{ "ConfigurableJoint-targetAngularVelocity", "This is a Vector3. It defines the desired angular velocity that the joint should rotate into." },
{ "ConfigurableJoint-targetPosition", "The desired position that the joint should move into." },
{ "ConfigurableJoint-targetRotation", "This is a Quaternion. It defines the desired rotation that the joint should rotate into." },
{ "ConfigurableJoint-targetVelocity", "The desired velocity that the joint should move along." },
{ "ConfigurableJoint-xDrive", "Definition of how the joint's movement will behave along its local X axis." },
{ "ConfigurableJoint-xMotion", "Allow movement along the X axis to be Free, completely Locked, or Limited according to Linear Limit." },
{ "ConfigurableJoint-yDrive", "Definition of how the joint's movement will behave along its local Y axis." },
{ "ConfigurableJoint-yMotion", "Allow movement along the Y axis to be Free, completely Locked, or Limited according to Linear Limit." },
{ "ConfigurableJoint-zDrive", "Definition of how the joint's movement will behave along its local Z axis." },
{ "ConfigurableJoint-zMotion", "Allow movement along the Z axis to be Free, completely Locked, or Limited according to Linear Limit." },
{ "ConfigurableJointMotion", "Constrains movement for a ConfigurableJoint along the 6 axes." },
{ "ConfigurableJointMotion.Free", "Motion along the axis will be completely free and completely unconstrained." },
{ "ConfigurableJointMotion.Limited", "Motion along the axis will be limited by the respective limit." },
{ "ConfigurableJointMotion.Locked", "Motion along the axis will be locked." },
{ "ConnectionTesterStatus", "The various test results the connection tester may return with." },
{ "ConnectionTesterStatus.Error", "Some unknown error occurred." },
{ "ConnectionTesterStatus.LimitedNATPunchthroughPortRestricted", "Port-restricted NAT type, can do NAT punchthrough to everyone except symmetric." },
{ "ConnectionTesterStatus.LimitedNATPunchthroughSymmetric", "Symmetric NAT type, cannot do NAT punchthrough to other symmetric types nor port restricted type." },
{ "ConnectionTesterStatus.NATpunchthroughAddressRestrictedCone", "Address-restricted cone type, NAT punchthrough fully supported." },
{ "ConnectionTesterStatus.NATpunchthroughFullCone", "Full cone type, NAT punchthrough fully supported." },
{ "ConnectionTesterStatus.PublicIPIsConnectable", "Public IP address detected and game listen port is accessible to the internet." },
{ "ConnectionTesterStatus.PublicIPNoServerStarted", "Public IP address detected but server is not initialized and no port is listening." },
{ "ConnectionTesterStatus.PublicIPPortBlocked", "Public IP address detected but the port is not connectable from the internet." },
{ "ConnectionTesterStatus.Undetermined", "Test result undetermined, still in progress." },
{ "ConstantForce", "A force applied constantly." },
{ "ConstantForce-force", "The force applied to the rigidbody every frame." },
{ "ConstantForce-relativeForce", "The force - relative to the rigid bodies coordinate system - applied every frame." },
{ "ConstantForce-relativeTorque", "The torque - relative to the rigid bodies coordinate system - applied every frame." },
{ "ConstantForce-torque", "The torque applied to the rigidbody every frame." },
{ "ContactPoint", "Describes a contact point where the collision occurs." },
{ "ContactPoint-normal", "Normal of the contact point." },
{ "ContactPoint-otherCollider", "The other collider in contact." },
{ "ContactPoint-point", "The point of contact." },
{ "ContactPoint-thisCollider", "The first collider in contact." },
{ "ContactPoint2D", "Details about a specific point of contact involved in a 2D physics collision." },
{ "ContactPoint2D-collider", "The collider attached to the object receiving the collision message." },
{ "ContactPoint2D-normal", "Surface normal at the contact point." },
{ "ContactPoint2D-otherCollider", "The incoming collider involved in the collision at this contact point." },
{ "ContactPoint2D-point", "The point of contact between the two colliders in world space." },
{ "ContextMenu", "The ContextMenu attribute allows you to add commands to the context menu." },
{ "ContextMenu-ctor", "Adds the function to the context menu of the component." },
{ "ContextMenuItemAttribute", "Use this attribute to add a context menu to a field that calls a named method." },
{ "ContextMenuItemAttribute-ctor", "Use this attribute to add a context menu to a field that calls a named method." },
{ "ContextMenuItemAttribute-function", "The name of the function that should be called." },
{ "ContextMenuItemAttribute-name", "The name of the context menu item." },
{ "ControllerColliderHit", "ControllerColliderHit is used by CharacterController.OnControllerColliderHit to give detailed information about the collision and how to deal with it." },
{ "ControllerColliderHit-collider", "The collider that was hit by the controller." },
{ "ControllerColliderHit-controller", "The controller that hit the collider." },
{ "ControllerColliderHit-gameObject", "The game object that was hit by the controller." },
{ "ControllerColliderHit-moveDirection", "Approximately the direction from the center of the capsule to the point we touch." },
{ "ControllerColliderHit-moveLength", "How far the character has travelled until it hit the collider." },
{ "ControllerColliderHit-normal", "The normal of the surface we collided with in world space." },
{ "ControllerColliderHit-point", "The impact point in world space." },
{ "ControllerColliderHit-rigidbody", "The rigidbody that was hit by the controller." },
{ "ControllerColliderHit-transform", "The transform that was hit by the controller." },
{ "Coroutine", "MonoBehaviour.StartCoroutine returns a Coroutine. Instances of this class are only used to reference these coroutines and do not hold any exposed properties or functions." },
{ "CrashReport", "Holds data for a single application crash event and provides access to all gathered crash reports." },
{ "CrashReport-lastReport", "Returns last crash report, or null if no reports are available." },
{ "CrashReport-reports", "Returns all currently available reports in a new array." },
{ "CrashReport-text", "Crash report data as formatted text." },
{ "CrashReport-time", "Time, when the crash occured." },
{ "CrashReport.Remove", "Remove report from available reports list." },
{ "CrashReport.RemoveAll", "Remove all reports from available reports list." },
{ "Cubemap", "Class for handling cube maps, Use this to create or modify existing cube map assets." },
{ "Cubemap-ctor", "Create a new empty cubemap texture." },
{ "Cubemap-format", "The format of the pixel data in the texture (Read Only)." },
{ "Cubemap.Apply", "Actually apply all previous SetPixel and SetPixels changes." },
{ "Cubemap.GetPixel", "Returns pixel color at coordinates (face, x, y)." },
{ "Cubemap.GetPixels", "Returns pixel colors of a cubemap face." },
{ "Cubemap.SetPixel", "Sets pixel color at coordinates (face, x, y)." },
{ "Cubemap.SetPixels", "Sets pixel colors of a cubemap face." },
{ "Cubemap.SmoothEdges", "Performs smoothing of near edge regions." },
{ "CubemapFace", "Cubemap face." },
{ "CubemapFace.NegativeX", "Left facing side (-x)." },
{ "CubemapFace.NegativeY", "Downward facing side (-y)." },
{ "CubemapFace.NegativeZ", "Backward facing side (-z)." },
{ "CubemapFace.PositiveX", "Right facing side (+x)." },
{ "CubemapFace.PositiveY", "Upwards facing side (+y)." },
{ "CubemapFace.PositiveZ", "Forward facing side (+z)." },
{ "Cursor", "Cursor API for setting the cursor that is used for rendering." },
{ "Cursor.SetCursor", "Change the mouse cursor to the set texture OnMouseEnter." },
{ "CursorMode", "How should the custom cursor be rendered." },
{ "CursorMode.Auto", "Use hardware cursors on supported platforms." },
{ "CursorMode.ForceSoftware", "Force the use of software cursors." },
{ "CustomEditor", "Tells an Editor class which run-time type it's an editor for." },
{ "CustomEditor-ctor", "Defines which object type the custom editor class can edit." },
{ "CustomPreviewAttribute", "Adds an extra preview in the Inspector for the specified type." },
{ "CustomPreviewAttribute-ctor", "Tells a DefaultPreview which class it's a preview for." },
{ "CustomPropertyDrawer", "Tells a custom PropertyDrawer or DecoratorDrawer which run-time Serializable class or PropertyAttribute it's a drawer for." },
{ "CustomPropertyDrawer-ctor", "Tells a PropertyDrawer or DecoratorDrawer class which run-time class or attribute it's a drawer for." },
{ "Debug", "Class containing methods to ease debugging while developing a game." },
{ "Debug-developerConsoleVisible", "Opens or closes developer console." },
{ "Debug-isDebugBuild", "In the Build Settings dialog there is a check box called \"Development Build\"." },
{ "Debug.Break", "Pauses the editor." },
{ "Debug.ClearDeveloperConsole", "Clears errors from the developer console." },
{ "Debug.DrawLine", "Draws a line between specified start and end points." },
{ "Debug.DrawRay", "Draws a line from start to start + dir in world coordinates." },
{ "Debug.Log", "Logs message to the Unity Console." },
{ "Debug.LogError", "A variant of Debug.Log that logs an error message to the console." },
{ "Debug.LogException", "A variant of Debug.Log that logs an error message from an exception to the console." },
{ "Debug.LogWarning", "A variant of Debug.Log that logs a warning message to the console." },
{ "DecoratorDrawer", "Base class to derive custom decorator drawers from." },
{ "DecoratorDrawer-attribute", "The PropertyAttribute for the decorator. (Read Only)" },
{ "DecoratorDrawer.GetHeight", "Override this method to specify how tall the GUI for this decorator is in pixels." },
{ "DecoratorDrawer.OnGUI", "Override this method to make your own GUI for the decorator." },
{ "DepthTextureMode", "Depth texture generation mode for Camera." },
{ "DepthTextureMode.Depth", "Generate a depth texture." },
{ "DepthTextureMode.DepthNormals", "Generate a depth + normals texture." },
{ "DepthTextureMode.None", "Do not generate depth texture (Default)." },
{ "DetailPrototype", "Detail prototype used by the Terrain GameObject." },
{ "DetailPrototype-bendFactor", "Bend factor of the detailPrototype." },
{ "DetailPrototype-dryColor", "Color when the DetailPrototypes are \"dry\"." },
{ "DetailPrototype-healthyColor", "Color when the DetailPrototypes are \"healthy\"." },
{ "DetailPrototype-maxHeight", "Maximum height of the grass billboards (if render mode is GrassBillboard)." },
{ "DetailPrototype-maxWidth", "Maximum width of the grass billboards (if render mode is GrassBillboard)." },
{ "DetailPrototype-minHeight", "Minimum height of the grass billboards (if render mode is GrassBillboard)." },
{ "DetailPrototype-minWidth", "Minimum width of the grass billboards (if render mode is GrassBillboard)." },
{ "DetailPrototype-noiseSpread", "How spread out is the noise for the DetailPrototype." },
{ "DetailPrototype-prototype", "GameObject used by the DetailPrototype." },
{ "DetailPrototype-prototypeTexture", "Texture used by the DetailPrototype." },
{ "DetailPrototype-renderMode", "Render mode for the DetailPrototype." },
{ "DetailRenderMode", "Render mode for detail prototypes." },
{ "DetailRenderMode.Grass", "The detail prototype will use the grass shader." },
{ "DetailRenderMode.GrassBillboard", "The detail prototype will be rendered as billboards that are always facing the camera." },
{ "DetailRenderMode.VertexLit", "Will show the prototype using diffuse shading." },
{ "DeviceOrientation", "Describes physical orientation of the device as determined by the OS." },
{ "DeviceOrientation.FaceDown", "The device is held parallel to the ground with the screen facing downwards." },
{ "DeviceOrientation.FaceUp", "The device is held parallel to the ground with the screen facing upwards." },
{ "DeviceOrientation.LandscapeLeft", "The device is in landscape mode, with the device held upright and the home button on the right side." },
{ "DeviceOrientation.LandscapeRight", "The device is in landscape mode, with the device held upright and the home button on the left side." },
{ "DeviceOrientation.Portrait", "The device is in portrait mode, with the device held upright and the home button at the bottom." },
{ "DeviceOrientation.PortraitUpsideDown", "The device is in portrait mode but upside down, with the device held upright and the home button at the top." },
{ "DeviceOrientation.Unknown", "The orientation of the device cannot be determined." },
{ "DeviceType", "Enumeration for SystemInfo.deviceType, denotes a coarse grouping of kinds of devices." },
{ "DeviceType.Console", "A stationary gaming console." },
{ "DeviceType.Desktop", "Desktop or laptop computer." },
{ "DeviceType.Handheld", "A handheld device like mobile phone or a tablet." },
{ "DeviceType.Unknown", "Device type is unknown. You should never see this in practice." },
{ "DisallowMultipleComponent", "Prevents MonoBehaviour of same type (or subtype) to be added more than once to a GameObject." },
{ "Display", "Provides access to a display / screen for rendering operations." },
{ "Display-colorBuffer", "Color RenderBuffer." },
{ "Display-depthBuffer", "Depth RenderBuffer." },
{ "Display-displays", "The list of currently connected Displays. Contains at least one (main) display." },
{ "Display-main", "Main Display." },
{ "Display-renderingHeight", "Rendering Height." },
{ "Display-renderingWidth", "Rendering Width." },
{ "Display-systemHeight", "System Height." },
{ "Display-systemWidth", "System Width." },
{ "Display.SetRenderingResolution", "Sets Rendering resolution for the display." },
{ "DistanceJoint2D", "Joint that keeps two Rigidbody2D objects a fixed distance apart." },
{ "DistanceJoint2D-distance", "The distance separating the two ends of the joint." },
{ "DistanceJoint2D-maxDistanceOnly", "Whether to maintain a maximum distance only or not. If not then the absolute distance will be maintained instead." },
{ "DistanceJoint2D.GetReactionForce", "Gets the reaction force of the joint given the specified timestep." },
{ "DistanceJoint2D.GetReactionTorque", "Gets the reaction torque of the joint given the specified timestep." },
{ "DragAndDrop", "Editor drag & drop operations." },
{ "DragAndDrop-activeControlID", "Get or set ID of currently active drag and drop control." },
{ "DragAndDrop-objectReferences", "References to objects being dragged." },
{ "DragAndDrop-paths", "The file names being dragged." },
{ "DragAndDrop-visualMode", "The visual indication of the drag." },
{ "DragAndDrop.AcceptDrag", "Accept a drag operation." },
{ "DragAndDrop.GetGenericData", "Get data associated with current drag and drop operation." },
{ "DragAndDrop.PrepareStartDrag", "Clears drag & drop data." },
{ "DragAndDrop.SetGenericData", "Set data associated with current drag and drop operation." },
{ "DragAndDrop.StartDrag", "Start a drag operation." },
{ "DragAndDropVisualMode", "Visual indication mode for Drag & Drop operation." },
{ "DragAndDropVisualMode.Copy", "Copy dragged objects." },
{ "DragAndDropVisualMode.Generic", "Generic drag operation." },
{ "DragAndDropVisualMode.Link", "Link dragged objects to target." },
{ "DragAndDropVisualMode.Move", "Move dragged objects." },
{ "DragAndDropVisualMode.None", "No indication (drag should not be performed)." },
{ "DragAndDropVisualMode.Rejected", "Rejected drag operation." },
{ "DrawCameraMode", "Drawing modes for Handles.DrawCamera." },
{ "DrawCameraMode.LightmapResolution", "Draw textured with overlaid lightmap resolution grid." },
{ "DrawCameraMode.Normal", "Draw the camera like it would be drawn in-game. This uses the clear flags of the camera." },
{ "DrawCameraMode.RenderPaths", "Draw color-coded render paths. Objects are colored Green for Deferred, Yellow for Forward and Red for VertexLit." },
{ "DrawCameraMode.Textured", "Draw the camera textured with selection wireframe and no background clearing." },
{ "DrawCameraMode.TexturedWire", "Draw the camera where all objects have a wireframe overlay. and no background clearing." },
{ "DrawCameraMode.Wireframe", "Draw the camera in wireframe and no background clearing." },
{ "DrawGizmo", "The DrawGizmo attribute allows you to supply a gizmo renderer for any Component." },
{ "DrawGizmo-ctor", "Defines when the gizmo should be invoked for drawing." },
{ "EdgeCollider2D", "Collider for 2D physics representing an arbitrary set of connected edges (lines) defined by its vertices." },
{ "EdgeCollider2D-edgeCount", "Gets the number of edges." },
{ "EdgeCollider2D-pointCount", "Gets the number of points." },
{ "EdgeCollider2D-points", "Get or set the points defining multiple continuous edges." },
{ "EdgeCollider2D.Reset", "Reset to a single edge consisting of two points." },
{ "Editor", "Base class to derive custom Editors from. Use this to create your own custom inspectors and editors for your objects." },
{ "Editor-serializedObject", "A SerializedObject representing the object or objects being inspected." },
{ "Editor-target", "The object being inspected." },
{ "Editor-targets", "An array of all the object being inspected." },
{ "Editor.CreateEditor", "Make a custom editor for obj or objects." },
{ "Editor.DrawDefaultInspector", "Draw the built-in inspector." },
{ "Editor.DrawHeader", "Call this function to draw the header of the editor." },
{ "Editor.DrawPreview", "The first entry point for Preview Drawing." },
{ "Editor.GetInfoString", "Implement this method to show asset information on top of the asset preview." },
{ "Editor.GetPreviewTitle", "Override this method if you want to change the label of the Preview area." },
{ "Editor.HasPreviewGUI", "Override this method in subclasses if you implement OnPreviewGUI." },
{ "Editor.OnInspectorGUI", "Implement this function to make a custom inspector." },
{ "Editor.OnInteractivePreviewGUI", "Implement to create your own interactive custom preview. Interactive custom previews are used in the preview area of the inspector and the object selector." },
{ "Editor.OnPreviewGUI", "Implement to create your own custom preview for the preview area of the inspector, primary editor headers and the object selector." },
{ "Editor.OnPreviewSettings", "Override this method if you want to show custom controls in the preview header." },
{ "Editor.OnSceneGUI", "Lets the Editor handle an event in the scene view." },
{ "Editor.RenderStaticPreview", "Override this method if you want to render a static preview that shows." },
{ "Editor.Repaint", "Repaint any inspectors that shows this editor." },
{ "Editor.UseDefaultMargins", "Override this method in subclasses to return false if you don't want default margins." },
{ "EditorApplication", "Main Application class." },
{ "EditorApplication-applicationContentsPath", "Path to the Unity editor contents folder. (Read Only)" },
{ "EditorApplication-applicationPath", "Returns the path to the Unity editor application. (Read Only)" },
{ "EditorApplication-currentScene", "The path of the scene that the user has currently open (Will be an empty string if no scene is currently open). (Read Only)" },
{ "EditorApplication-hierarchyWindowChanged", "Each time an object is (or a group of objects are) created, renamed, parented, unparented or destroyed this callback is raised." },
{ "EditorApplication-hierarchyWindowItemOnGUI", "Delegate for OnGUI events for every visible list item in the HierarchyWindow." },
{ "EditorApplication-isCompiling", "Is editor currently compiling scripts? (Read Only)" },
{ "EditorApplication-isPaused", "Is editor currently paused?" },
{ "EditorApplication-isPlaying", "Is editor currently in play mode?" },
{ "EditorApplication-isPlayingOrWillChangePlaymode", "Is editor either currently in play mode, or about to switch to it? (Read Only)" },
{ "EditorApplication-isUpdating", "Is editor currently updating? (Read Only)" },
{ "EditorApplication-modifierKeysChanged", "Delegate for changed keyboard modifier keys." },
{ "EditorApplication-playmodeStateChanged", "Delegate for play mode state changes." },
{ "EditorApplication-projectWindowChanged", "Callback raised whenever the state of the Project window changes." },
{ "EditorApplication-projectWindowItemOnGUI", "Delegate for OnGUI events for every visible list item in the ProjectWindow." },
{ "EditorApplication-searchChanged", "Callback raised whenever the contents of a window's search box are changed." },
{ "EditorApplication-timeSinceStartup", "The time since the editor was started. (Read Only)" },
{ "EditorApplication-update", "Delegate for generic updates." },
{ "EditorApplication.Beep", "Plays system beep sound." },
{ "EditorApplication.CallbackFunction", "Delegate to be called from EditorApplication callbacks." },
{ "EditorApplication.ExecuteMenuItem", "Invokes the menu item in the specified path." },
{ "EditorApplication.Exit", "Exit the Unity editor application." },
{ "EditorApplication.HierarchyWindowItemCallback", "Delegate to be called for every visible list item in the HierarchyWindow on every OnGUI event." },
{ "EditorApplication.LockReloadAssemblies", "Prevents loading of assemblies when it is inconvenient." },
{ "EditorApplication.NewScene", "Create a new scene." },
{ "EditorApplication.OpenProject", "Open another project." },
{ "EditorApplication.OpenScene", "Opens the scene at path." },
{ "EditorApplication.OpenSceneAdditive", "Opens the scene at path additively." },
{ "EditorApplication.ProjectWindowItemCallback", "Delegate to be called for every visible list item in the ProjectWindow on every OnGUI event." },
{ "EditorApplication.RepaintHierarchyWindow", "Can be used to ensure repaint of the HierarchyWindow." },
{ "EditorApplication.RepaintProjectWindow", "Can be used to ensure repaint of the ProjectWindow." },
{ "EditorApplication.SaveAssets", "Saves all serializable assets that have not yet been written to disk (eg. Materials)." },
{ "EditorApplication.SaveCurrentSceneIfUserWantsTo", "Ask the user if he wants to save the open scene." },
{ "EditorApplication.SaveScene", "Save the open scene." },
{ "EditorApplication.Step", "Perform a single frame step." },
{ "EditorApplication.UnlockReloadAssemblies", "Must be called after LockReloadAssemblies, to reenable loading of assemblies." },
{ "EditorCurveBinding", "Defines how a curve is attached to an object that it controls." },
{ "EditorCurveBinding-path", "The transform path of the object that is animated." },
{ "EditorCurveBinding-propertyName", "The property of the object that is animated." },
{ "EditorGUI", "These work pretty much like the normal GUI functions - and also have matching implementations in EditorGUILayout." },
{ "EditorGUI-actionKey", "Is the platform-dependent \"action\" modifier key held down? (Read Only)" },
{ "EditorGUI-indentLevel", "The indent level of the field labels." },
{ "EditorGUI-showMixedValue", "Makes the following controls give the appearance of editing multiple different values." },
{ "EditorGUI.BeginChangeCheck", "Check if any control was changed inside a block of code." },
{ "EditorGUI.BeginDisabledGroup", "Create a group of controls that can be disabled." },
{ "EditorGUI.BeginProperty", "Create a Property wrapper, useful for making regular GUI controls work with SerializedProperty." },
{ "EditorGUI.BoundsField", "Make Center & Extents field for entering a Bounds." },
{ "EditorGUI.ColorField", "Make a field for selecting a Color." },
{ "EditorGUI.CurveField", "Make a field for editing an AnimationCurve." },
{ "EditorGUI.DrawPreviewTexture", "Draws the texture within a rectangle." },
{ "EditorGUI.DrawTextureAlpha", "Draws the alpha channel of a texture within a rectangle." },
{ "EditorGUI.DropShadowLabel", "Draws a label with a drop shadow." },
{ "EditorGUI.EndChangeCheck", "Ends a change check started with BeginChangeCheck ()." },
{ "EditorGUI.EndDisabledGroup", "Ends a disabled group started with BeginDisabledGroup." },
{ "EditorGUI.EndProperty", "Ends a Property wrapper started with BeginProperty." },
{ "EditorGUI.EnumMaskField", "Make a field for enum based masks." },
{ "EditorGUI.EnumPopup", "Make an enum popup selection field." },
{ "EditorGUI.FloatField", "Make a text field for entering floats." },
{ "EditorGUI.FocusTextInControl", "Move keyboard focus to a named text field and begin editing of the content." },
{ "EditorGUI.Foldout", "Make a label with a foldout arrow to the left of it." },
{ "EditorGUI.GetPropertyHeight", "Get the height needed for a PropertyField control." },
{ "EditorGUI.HandlePrefixLabel", "Make a label for some control." },
{ "EditorGUI.HelpBox", "Make a help box with a message to the user." },
{ "EditorGUI.InspectorTitlebar", "Make an inspector-window-like titlebar." },
{ "EditorGUI.IntField", "Make a text field for entering integers." },
{ "EditorGUI.IntPopup", "Make an integer popup selection field." },
{ "EditorGUI.IntSlider", "Make a slider the user can drag to change an integer value between a min and a max." },
{ "EditorGUI.LabelField", "Make a label field. (Useful for showing read-only info.)" },
{ "EditorGUI.LayerField", "Make a layer selection field." },
{ "EditorGUI.MaskField", "Make a field for masks." },
{ "EditorGUI.MinMaxSlider", "Make a special slider the user can use to specify a range between a min and a max." },
{ "EditorGUI.MultiFloatField", "Make a multi-control with text fields for entering multiple floats in the same line." },
{ "EditorGUI.MultiPropertyField", "Make a multi-control with several property fields in the same line." },
{ "EditorGUI.ObjectField", "Make an object field. You can assign objects either by drag and drop objects or by selecting an object using the Object Picker." },
{ "EditorGUI.PasswordField", "Make a text field where the user can enter a password." },
{ "EditorGUI.Popup", "Make a generic popup selection field." },
{ "EditorGUI.PrefixLabel", "Make a label in front of some control." },
{ "EditorGUI.ProgressBar", "Make a progress bar." },
{ "EditorGUI.PropertyField", "Make a field for SerializedProperty." },
{ "EditorGUI.RectField", "Make an X, Y, W & H field for entering a Rect." },
{ "EditorGUI.SelectableLabel", "Make a selectable label field. (Useful for showing read-only info that can be copy-pasted.)" },
{ "EditorGUI.Slider", "Make a slider the user can drag to change a value between a min and a max." },
{ "EditorGUI.TagField", "Make a tag selection field." },
{ "EditorGUI.TextArea", "Make a text area." },
{ "EditorGUI.TextField", "Make a text field." },
{ "EditorGUI.Toggle", "Make a toggle." },
{ "EditorGUI.ToggleLeft", "Make a toggle field where the toggle is to the left and the label immediately to the right of it." },
{ "EditorGUI.Vector2Field", "Make an X & Y field for entering a Vector2." },
{ "EditorGUI.Vector3Field", "Make an X, Y & Z field for entering a Vector3." },
{ "EditorGUI.Vector4Field", "Make an X, Y, Z & W field for entering a Vector4." },
{ "EditorGUILayout", "Auto-layouted version of EditorGUI." },
{ "EditorGUILayout.BeginFadeGroup", "Begins a group that can be be hidden/shown and the transition will be animated." },
{ "EditorGUILayout.BeginHorizontal", "Begin a horizontal group and get its rect back." },
{ "EditorGUILayout.BeginScrollView", "Begin an automatically layouted scrollview." },
{ "EditorGUILayout.BeginToggleGroup", "Begin a vertical group with a toggle to enable or disable all the controls within at once." },
{ "EditorGUILayout.BeginVertical", "Begin a vertical group and get its rect back." },
{ "EditorGUILayout.BoundsField", "Make Center & Extents field for entering a Bounds." },
{ "EditorGUILayout.ColorField", "Make a field for selecting a Color." },
{ "EditorGUILayout.CurveField", "Make a field for editing an AnimationCurve." },
{ "EditorGUILayout.EndFadeGroup", "Closes a group started with BeginFadeGroup." },
{ "EditorGUILayout.EndHorizontal", "Close a group started with BeginHorizontal." },
{ "EditorGUILayout.EndScrollView", "Ends a scrollview started with a call to BeginScrollView." },
{ "EditorGUILayout.EndToggleGroup", "Close a group started with BeginToggleGroup." },
{ "EditorGUILayout.EndVertical", "Close a group started with BeginVertical." },
{ "EditorGUILayout.EnumMaskField", "Make a field for enum based masks." },
{ "EditorGUILayout.EnumPopup", "Make an enum popup selection field." },
{ "EditorGUILayout.FloatField", "Make a text field for entering float values." },
{ "EditorGUILayout.Foldout", "Make a label with a foldout arrow to the left of it." },
{ "EditorGUILayout.GetControlRect", "Get a rect for an Editor control." },
{ "EditorGUILayout.HelpBox", "Make a help box with a message to the user." },
{ "EditorGUILayout.InspectorTitlebar", "Make an inspector-window-like titlebar." },
{ "EditorGUILayout.IntField", "Make a text field for entering integers." },
{ "EditorGUILayout.IntPopup", "Make an integer popup selection field." },
{ "EditorGUILayout.IntSlider", "Make a slider the user can drag to change an integer value between a min and a max." },
{ "EditorGUILayout.LabelField", "Make a label field. (Useful for showing read-only info.)" },
{ "EditorGUILayout.LayerField", "Make a layer selection field." },
{ "EditorGUILayout.MaskField", "Make a field for masks." },
{ "EditorGUILayout.MinMaxSlider", "Make a special slider the user can use to specify a range between a min and a max." },
{ "EditorGUILayout.ObjectField", "Make a field to receive any object type." },
{ "EditorGUILayout.PasswordField", "Make a text field where the user can enter a password." },
{ "EditorGUILayout.Popup", "Make a generic popup selection field." },
{ "EditorGUILayout.PrefixLabel", "Make a label in front of some control." },
{ "EditorGUILayout.PropertyField", "Make a field for SerializedProperty." },
{ "EditorGUILayout.RectField", "Make an X, Y, W & H field for entering a Rect." },
{ "EditorGUILayout.SelectableLabel", "Make a selectable label field. (Useful for showing read-only info that can be copy-pasted.)" },
{ "EditorGUILayout.Slider", "Make a slider the user can drag to change a value between a min and a max." },
{ "EditorGUILayout.Space", "Make a small space between the previous control and the following." },
{ "EditorGUILayout.TagField", "Make a tag selection field." },
{ "EditorGUILayout.TextArea", "Make a text area." },
{ "EditorGUILayout.TextField", "Make a text field." },
{ "EditorGUILayout.Toggle", "Make a toggle." },
{ "EditorGUILayout.ToggleLeft", "Make a toggle field where the toggle is to the left and the label immediately to the right of it." },
{ "EditorGUILayout.Vector2Field", "Make an X & Y field for entering a Vector2." },
{ "EditorGUILayout.Vector3Field", "Make an X, Y & Z field for entering a Vector3." },
{ "EditorGUILayout.Vector4Field", "Make an X, Y, Z & W field for entering a Vector4." },
{ "EditorGUIUtility", "Miscellaneous helper stuff for EditorGUI." },
{ "EditorGUIUtility-currentViewWidth", "The width of the GUI area for the current EditorWindow or other view." },
{ "EditorGUIUtility-editingTextField", "Is a text field currently editing text?" },
{ "EditorGUIUtility-fieldWidth", "The minimum width in pixels reserved for the fields of Editor GUI controls." },
{ "EditorGUIUtility-hierarchyMode", "Is the Editor GUI is hierarchy mode?" },
{ "EditorGUIUtility-isProSkin", "Is the user currently using the pro skin? (Read Only)" },
{ "EditorGUIUtility-labelWidth", "The width in pixels reserved for labels of Editor GUI controls." },
{ "EditorGUIUtility-singleLineHeight", "Get the height used for a single Editor control such as a one-line EditorGUI.TextField or EditorGUI.Popup." },
{ "EditorGUIUtility-standardVerticalSpacing", "Get the height used by default for vertical spacing between controls." },
{ "EditorGUIUtility-systemCopyBuffer", "The system copy buffer." },
{ "EditorGUIUtility-whiteTexture", "Get a white texture." },
{ "EditorGUIUtility-wideMode", "Is the Editor GUI currently in wide mode?" },
{ "EditorGUIUtility.AddCursorRect", "Add a custom mouse pointer to a control." },
{ "EditorGUIUtility.CommandEvent", "Creates an event." },
{ "EditorGUIUtility.DrawColorSwatch", "Draw a color swatch." },
{ "EditorGUIUtility.DrawCurveSwatch", "Draw a curve swatch." },
{ "EditorGUIUtility.DrawRegionSwatch", "Draw swatch with a filled region between two SerializedProperty curves." },
{ "EditorGUIUtility.FindTexture", "Get a texture from its source filename." },
{ "EditorGUIUtility.GetBuiltinSkin", "Get one of the built-in GUI skins, which can be the game view, inspector or scene view skin as chosen by the parameter." },
{ "EditorGUIUtility.GetIconSize", "Get the size that has been set using SetIconSize." },
{ "EditorGUIUtility.GetObjectPickerControlID", "The controlID of the currently showing object picker." },
{ "EditorGUIUtility.GetObjectPickerObject", "The object currently selected in the object picker." },
{ "EditorGUIUtility.HasObjectThumbnail", "Does a given class have per-object thumbnails?" },
{ "EditorGUIUtility.HSVToRGB", "Convert a set of HSV values to an RGB Color." },
{ "EditorGUIUtility.IconContent", "Fetch the GUIContent from the Unity builtin resources with the given name." },
{ "EditorGUIUtility.Load", "Load a built-in resource." },
{ "EditorGUIUtility.LoadRequired", "Load a built-in resource that has to be there." },
{ "EditorGUIUtility.LookLikeControls", "Make all EditorGUI look like regular controls." },
{ "EditorGUIUtility.ObjectContent", "Return a GUIContent object with the name and icon of an Object." },
{ "EditorGUIUtility.PingObject", "Ping an object in a window like clicking it in an inspector." },
{ "EditorGUIUtility.QueueGameViewInputEvent", "Send an input event into the game." },
{ "EditorGUIUtility.RenderGameViewCameras", "Render all ingame cameras." },
{ "EditorGUIUtility.RGBToHSV", "Convert a color from RGB to HSV color space." },
{ "EditorGUIUtility.SetIconSize", "Set icons rendered as part of GUIContent to be rendered at a specific size." },
{ "EditorGUIUtility.ShowObjectPicker", "Show the object picker from code." },
{ "EditorPrefs", "Stores and accesses Unity editor preferences." },
{ "EditorPrefs.DeleteAll", "Removes all keys and values from the preferences. Use with caution." },
{ "EditorPrefs.DeleteKey", "Removes key and its corresponding value from the preferences." },
{ "EditorPrefs.GetBool", "Returns the value corresponding to key in the preference file if it exists." },
{ "EditorPrefs.GetFloat", "Returns the value corresponding to key in the preference file if it exists." },
{ "EditorPrefs.GetInt", "Returns the value corresponding to key in the preference file if it exists." },
{ "EditorPrefs.GetString", "Returns the value corresponding to key in the preference file if it exists." },
{ "EditorPrefs.HasKey", "Returns true if key exists in the preferences." },
{ "EditorPrefs.SetBool", "Sets the value of the preference identified by key." },
{ "EditorPrefs.SetFloat", "Sets the value of the preference identified by key." },
{ "EditorPrefs.SetInt", "Sets the value of the preference identified by key." },
{ "EditorPrefs.SetString", "Sets the value of the preference identified by key." },
{ "EditorSkin", "Enum that selects which skin to return from EditorGUIUtility.GetBuiltinSkin." },
{ "EditorSkin.Game", "The skin used for game views." },
{ "EditorSkin.Inspector", "The skin used for inspectors." },
{ "EditorSkin.Scene", "The skin used for scene views." },
{ "EditorStyles", "Common GUIStyles used for EditorGUI controls." },
{ "EditorStyles-boldFont", "Bold font." },
{ "EditorStyles-boldLabel", "Style for bold label." },
{ "EditorStyles-colorField", "Style used for headings for Color fields." },
{ "EditorStyles-foldout", "Style used for headings for EditorGUI.Foldout." },
{ "EditorStyles-foldoutPreDrop", "Style used for headings for EditorGUI.Foldout." },
{ "EditorStyles-inspectorDefaultMargins", "Wrap content in a vertical group with this style to get the default margins used in the Inspector." },
{ "EditorStyles-inspectorFullWidthMargins", "Wrap content in a vertical group with this style to get full width margins in the Inspector." },
{ "EditorStyles-label", "Style used for the labelled on all EditorGUI overloads that take a prefix label." },
{ "EditorStyles-largeLabel", "Style for label with large font." },
{ "EditorStyles-layerMaskField", "Style used for headings for Layer masks." },
{ "EditorStyles-miniBoldFont", "Mini Bold font." },
{ "EditorStyles-miniBoldLabel", "Style for mini bold label." },
{ "EditorStyles-miniButton", "Style used for a standalone small button." },
{ "EditorStyles-miniButtonLeft", "Style used for the leftmost button in a horizontal button group." },
{ "EditorStyles-miniButtonMid", "Style used for the middle buttons in a horizontal group." },
{ "EditorStyles-miniButtonRight", "Style used for the rightmost button in a horizontal group." },
{ "EditorStyles-miniFont", "Mini font." },
{ "EditorStyles-miniLabel", "Style for label with small font." },
{ "EditorStyles-miniTextField", "Smaller text field." },
{ "EditorStyles-numberField", "Style used for field editors for numbers." },
{ "EditorStyles-objectField", "Style used for headings for object fields." },
{ "EditorStyles-objectFieldThumb", "Style used for headings for the Select button in object fields." },
{ "EditorStyles-popup", "Style used for EditorGUI.Popup, EditorGUI.EnumPopup,." },
{ "EditorStyles-radioButton", "Style used for a radio button." },
{ "EditorStyles-standardFont", "Standard font." },
{ "EditorStyles-textArea", "Style used for EditorGUI.TextArea." },
{ "EditorStyles-textField", "Style used for EditorGUI.TextField." },
{ "EditorStyles-toggle", "Style used for headings for EditorGUI.Toggle." },
{ "EditorStyles-toggleGroup", "Style used for headings for EditorGUILayout.BeginToggleGroup." },
{ "EditorStyles-toolbar", "Toolbar background from top of windows." },
{ "EditorStyles-toolbarButton", "Style for Button and Toggles in toolbars." },
{ "EditorStyles-toolbarDropDown", "Toolbar Dropdown." },
{ "EditorStyles-toolbarPopup", "Toolbar Popup." },
{ "EditorStyles-toolbarTextField", "Toolbar text field." },
{ "EditorStyles-whiteBoldLabel", "Style for white bold label." },
{ "EditorStyles-whiteLabel", "Style for white label." },
{ "EditorStyles-whiteLargeLabel", "Style for white large label." },
{ "EditorStyles-whiteMiniLabel", "Style for white mini label." },
{ "EditorStyles-wordWrappedLabel", "Style for word wrapped label." },
{ "EditorStyles-wordWrappedMiniLabel", "Style for word wrapped mini label." },
{ "EditorUserBuildSettings-activeBuildTarget", "The currently active build target." },
{ "EditorUserBuildSettings-activeBuildTargetChanged", "Triggered in response to SwitchActiveBuildTarget." },
{ "EditorUserBuildSettings-activeScriptCompilationDefines", "DEFINE directives for the compiler." },
{ "EditorUserBuildSettings-allowDebugging", "Enable source-level debuggers to connect." },
{ "EditorUserBuildSettings-androidBuildSubtarget", "Android platform options." },
{ "EditorUserBuildSettings-appendProject", "Append (rather than replace) the build of an iOS Xcode project." },
{ "EditorUserBuildSettings-blackberryBuildSubtarget", "The texture compression type to be used when building." },
{ "EditorUserBuildSettings-blackberryBuildType", "The build type to be used." },
{ "EditorUserBuildSettings-connectProfiler", "Start the player with a connection to the profiler." },
{ "EditorUserBuildSettings-development", "Enables a development build." },
{ "EditorUserBuildSettings-explicitNullChecks", "Are null references actively checked?" },
{ "EditorUserBuildSettings-installInBuildFolder", "Place the built player in the build folder." },
{ "EditorUserBuildSettings-metroGenerateReferenceProjects", "Generate and reference C# projects from your main solution." },
{ "EditorUserBuildSettings-psp2BuildSubtarget", "PS Vita Build subtarget." },
{ "EditorUserBuildSettings-sceBuildSubtarget", "SCE Build subtarget." },
{ "EditorUserBuildSettings-selectedBuildTargetGroup", "The currently selected build target group." },
{ "EditorUserBuildSettings-selectedStandaloneTarget", "The currently selected target for a standalone build." },
{ "EditorUserBuildSettings-symlinkLibraries", "Symlink runtime libraries with an iOS Xcode project." },
{ "EditorUserBuildSettings-tizenBuildSubtarget", "The texture compression type to be used when building." },
{ "EditorUserBuildSettings-webPlayerOfflineDeployment", "Build the webplayer along with the UnityObject.js file (so it doesn't need to be downloaded)." },
{ "EditorUserBuildSettings-webPlayerStreamed", "Select the streaming option for a webplayer build." },
{ "EditorUserBuildSettings-xboxBuildSubtarget", "Xbox Build subtarget." },
{ "EditorUserBuildSettings-xboxRunMethod", "Selected Xbox Run Method." },
{ "EditorUserBuildSettings.GetBuildLocation", "Get the current location for the build." },
{ "EditorUserBuildSettings.SetBuildLocation", "Set a new location for the build." },
{ "EditorUserBuildSettings.SwitchActiveBuildTarget", "Select a new build target to be active." },
{ "EditorUtility", "Editor utility functions." },
{ "EditorUtility.ClearProgressBar", "Removes progress bar." },
{ "EditorUtility.CollectDeepHierarchy", "Collect all objects in the hierarchy rooted at each of the given objects. This is most useful for linearizing entire GameObject hierarchies including all their components." },
{ "EditorUtility.CollectDependencies", "Calculates and returns a list of all assets the assets listed in roots depend on." },
{ "EditorUtility.CompressTexture", "Compress a texture." },
{ "EditorUtility.CopySerialized", "Copy all settings of a Unity Object." },
{ "EditorUtility.CreateGameObjectWithHideFlags", "Creates a game object with HideFlags and specified components." },
{ "EditorUtility.DisplayCancelableProgressBar", "Displays or updates a progress bar that has a cancel button." },
{ "EditorUtility.DisplayDialog", "Displays a modal dialog." },
{ "EditorUtility.DisplayDialogComplex", "Displays a modal dialog with three buttons." },
{ "EditorUtility.DisplayPopupMenu", "Displays a popup menu." },
{ "EditorUtility.DisplayProgressBar", "Displays or updates a progress bar." },
{ "EditorUtility.ExtractOggFile", "Saves an AudioClip or MovieTexture to a file." },
{ "EditorUtility.FocusProjectWindow", "Brings the project window to the front and focuses it." },
{ "EditorUtility.FormatBytes", "Returns a text for a number of bytes." },
{ "EditorUtility.GetObjectEnabled", "Is the object enabled (0 disabled, 1 enabled, -1 has no enabled button)." },
{ "EditorUtility.InstanceIDToObject", "Translates an instance ID to a reference to an object." },
{ "EditorUtility.IsPersistent", "Determines if an object is stored on disk." },
{ "EditorUtility.NaturalCompare", "Human-like sorting." },
{ "EditorUtility.OpenFilePanel", "Displays the \"open file\" dialog and returns the selected path name." },
{ "EditorUtility.OpenFolderPanel", "Displays the \"open folder\" dialog and returns the selected path name." },
{ "EditorUtility.SaveFilePanel", "Displays the \"save file\" dialog and returns the selected path name." },
{ "EditorUtility.SaveFilePanelInProject", "Displays the \"save file\" dialog in the Assets folder of the project and returns the selected path name." },
{ "EditorUtility.SaveFolderPanel", "Displays the \"save folder\" dialog and returns the selected path name." },
{ "EditorUtility.SetDirty", "Marks target object as dirty." },
{ "EditorUtility.SetObjectEnabled", "Set the enabled state of the object." },
{ "EditorUtility.SetSelectedWireframeHidden", "Set whether the renderer's wireframe will be hidden when the renderer's gameobject is selected." },
{ "EditorUtility.UnloadUnusedAssets", "Unloads assets that are not used." },
{ "EditorUtility.UnloadUnusedAssetsIgnoreManagedReferences", "Unloads assets that are not used, including the ones that are referenced only from scripts." },
{ "EditorWindow", "Derive from this class to create an editor window." },
{ "EditorWindow-autoRepaintOnSceneChange", "Does the window automatically repaint whenever the scene has changed?" },
{ "EditorWindow-focusedWindow", "The EditorWindow which currently has keyboard focus. (Read Only)" },
{ "EditorWindow-maximized", "Is this window maximized." },
{ "EditorWindow-maxSize", "The maximum size of this window." },
{ "EditorWindow-minSize", "The minimum size of this window." },
{ "EditorWindow-mouseOverWindow", "The EditorWindow currently under the mouse cursor. (Read Only)" },
{ "EditorWindow-position", "The position of the window in screen space." },
{ "EditorWindow-title", "The title of this window." },
{ "EditorWindow-wantsMouseMove", "Does the GUI in this editor window want MouseMove events?" },
{ "EditorWindow.BeginWindows", "Mark the beginning area of all popup windows." },
{ "EditorWindow.Close", "Close the editor window." },
{ "EditorWindow.EndWindows", "Close a window group started with EditorWindow.BeginWindows." },
{ "EditorWindow.Focus", "Moves keyboard focus to this EditorWindow." },
{ "EditorWindow.FocusWindowIfItsOpen", "Focuses the first found EditorWindow of specified type if it is open." },
{ "EditorWindow.GetWindow", "Returns the first EditorWindow of type t which is currently on the screen." },
{ "EditorWindow.GetWindowWithRect", "Returns the first EditorWindow of type t which is currently on the screen." },
{ "EditorWindow.OnDestroy", "OnDestroy is called when the EditorWindow is closed." },
{ "EditorWindow.OnFocus", "Called when the window gets keyboard focus." },
{ "EditorWindow.OnGUI", "Implement your own editor GUI here." },
{ "EditorWindow.OnHierarchyChange", "Called whenever the scene hierarchy has changed." },
{ "EditorWindow.OnInspectorUpdate", "OnInspectorUpdate is called at 10 frames per second to give the inspector a chance to update." },
{ "EditorWindow.OnLostFocus", "Called when the window loses keyboard focus." },
{ "EditorWindow.OnProjectChange", "Called whenever the project has changed." },
{ "EditorWindow.OnSelectionChange", "Called whenever the selection has changed." },
{ "EditorWindow.RemoveNotification", "Stop showing notification message." },
{ "EditorWindow.Repaint", "Make the window repaint." },
{ "EditorWindow.SendEvent", "Sends an Event to a window." },
{ "EditorWindow.Show", "Show the EditorWindow." },
{ "EditorWindow.ShowAsDropDown", "Show window with dropdown behaviour (e.g. window is closed when it loses focus) and having." },
{ "EditorWindow.ShowAuxWindow", "Show the editor window in the auxiliary window." },
{ "EditorWindow.ShowNotification", "Show a notification message." },
{ "EditorWindow.ShowPopup", "Used for popup style windows." },
{ "EditorWindow.ShowUtility", "Show the EditorWindow as a floating utility window." },
{ "EditorWindow.Update", "Called 100 times per second on all visible windows." },
{ "Event", "A UnityGUI event." },
{ "Event-alt", "Is Alt/Option key held down? (Read Only)" },
{ "Event-button", "Which mouse button was pressed." },
{ "Event-capsLock", "Is Caps Lock on? (Read Only)" },
{ "Event-character", "The character typed." },
{ "Event-clickCount", "How many consecutive mouse clicks have we received." },
{ "Event-command", "Is Command/Windows key held down? (Read Only)" },
{ "Event-commandName", "The name of an ExecuteCommand or ValidateCommand Event." },
{ "Event-control", "Is Control key held down? (Read Only)" },
{ "Event-current", "The current event that's being processed right now." },
{ "Event-delta", "The relative movement of the mouse compared to last event." },
{ "Event-functionKey", "Is the current keypress a function key? (Read Only)" },
{ "Event-isKey", "Is this event a keyboard event? (Read Only)" },
{ "Event-isMouse", "Is this event a mouse event? (Read Only)" },
{ "Event-keyCode", "The raw key code for keyboard events." },
{ "Event-modifiers", "Which modifier keys are held down." },
{ "Event-mousePosition", "The mouse position." },
{ "Event-numeric", "Is the current keypress on the numeric keyboard? (Read Only)" },
{ "Event-shift", "Is Shift held down? (Read Only)" },
{ "Event-type", "The type of event." },
{ "Event.GetTypeForControl", "Get a filtered event type for a given control ID." },
{ "Event.KeyboardEvent", "Create a keyboard event." },
{ "Event.PopEvent", "Get the next queued [Event] from the event system." },
{ "Event.Use", "Use this event." },
{ "EventModifiers", "Types of modifier key that can be active during a keystroke event." },
{ "EventModifiers.Alt", "Alt key." },
{ "EventModifiers.CapsLock", "Caps lock key." },
{ "EventModifiers.Command", "Command key (Mac)." },
{ "EventModifiers.Control", "Control key." },
{ "EventModifiers.FunctionKey", "Function key." },
{ "EventModifiers.Numeric", "Num lock key." },
{ "EventModifiers.Shift", "Shift key." },
{ "Events.UnityAction", "Zero argument delegate used by UnityEvents." },
{ "Events.UnityAction_1", "One argument delegate used by UnityEvents." },
{ "Events.UnityAction_2", "Two argument delegate used by UnityEvents." },
{ "Events.UnityAction_3", "Three argument delegate used by UnityEvents." },
{ "Events.UnityAction_4", "Four argument delegate used by UnityEvents." },
{ "EventType", "Types of UnityGUI input and processing events." },
{ "EventType.ContextClick", "User has right-clicked (or control-clicked on the mac)." },
{ "EventType.DragExited", "Editor only: drag & drop operation exited." },
{ "EventType.DragPerform", "Editor only: drag & drop operation performed." },
{ "EventType.DragUpdated", "Editor only: drag & drop operation updated." },
{ "EventType.ExecuteCommand", "Execute a special command (eg. copy & paste)." },
{ "EventType.Ignore", "Event should be ignored." },
{ "EventType.KeyDown", "A keyboard key was pressed." },
{ "EventType.KeyUp", "A keyboard key was released." },
{ "EventType.Layout", "A layout event." },
{ "EventType.MouseDown", "Mouse button was pressed." },
{ "EventType.MouseDrag", "Mouse was dragged." },
{ "EventType.MouseMove", "Mouse was moved (editor views only)." },
{ "EventType.MouseUp", "Mouse button was released." },
{ "EventType.Repaint", "A repaint event. One is sent every frame." },
{ "EventType.ScrollWheel", "The scroll wheel was moved." },
{ "EventType.Used", "Already processed event." },
{ "EventType.ValidateCommand", "Validates a special command (e.g. copy & paste)." },
{ "ExecuteInEditMode", "Makes a script execute in edit mode." },
{ "ExportPackageOptions", "Export package option. Multiple options can be combined together using the | operator." },
{ "ExportPackageOptions.Default", "Default mode. Will not include dependencies or subdirectories nor include Library assets unless specifically included in the asset list." },
{ "ExportPackageOptions.IncludeDependencies", "In addition to the assets paths listed, all dependent assets will be included as well." },
{ "ExportPackageOptions.IncludeLibraryAssets", "The exported package will include all library assets, ie. the project settings located in the Library folder of the project." },
{ "ExportPackageOptions.Interactive", "The export operation will be run asynchronously and reveal the exported package file in a file browser window after the export is finished." },
{ "ExportPackageOptions.Recurse", "Will recurse through any subdirectories listed and include all assets inside them." },
{ "FFTWindow", "Spectrum analysis windowing types." },
{ "FFTWindow.Blackman", "W[n] = 0.42 - (0.5 * COS(n/N) ) + (0.08 * COS(2.0 * n/N) )." },
{ "FFTWindow.BlackmanHarris", "W[n] = 0.35875 - (0.48829 * COS(1.0 * n/N)) + (0.14128 * COS(2.0 * n/N)) - (0.01168 * COS(3.0 * n/N))." },
{ "FFTWindow.Hamming", "W[n] = 0.54 - (0.46 * COS(n/N) )." },
{ "FFTWindow.Hanning", "W[n] = 0.5 * (1.0 - COS(n/N) )." },
{ "FFTWindow.Rectangular", "W[n] = 1.0." },
{ "FFTWindow.Triangle", "W[n] = TRI(2n/N)." },
{ "FileUtil", "Lets you do move, copy, delete operations over files or directories." },
{ "FileUtil.CopyFileOrDirectory", "Copies a file or a directory." },
{ "FileUtil.CopyFileOrDirectoryFollowSymlinks", "Copies the file or directory." },
{ "FileUtil.DeleteFileOrDirectory", "Deletes a file or a directory given a path." },
{ "FileUtil.GetUniqueTempPathInProject", "Returns a unique path in the Temp folder within your current project." },
{ "FileUtil.MoveFileOrDirectory", "Moves a file or a directory from a given path to another path." },
{ "FileUtil.ReplaceDirectory", "Replaces a directory." },
{ "FileUtil.ReplaceFile", "Replaces a file." },
{ "FilterMode", "Filtering mode for textures. Corresponds to the settings in a texture inspector." },
{ "FilterMode.Bilinear", "Bilinear filtering - texture samples are averaged." },
{ "FilterMode.Point", "Point filtering - texture pixels become blocky up close." },
{ "FilterMode.Trilinear", "Trilinear filtering - texture samples are averaged and also blended between mipmap levels." },
{ "FixedJoint", "The Fixed joint groups together 2 rigidbodies, making them stick together in their bound position." },
{ "Flare", "A flare asset. Read more about flares in the components reference." },
{ "Flash.ActionScript", "Inline ActionScript support." },
{ "Flash.ActionScript.Expression", "Emits an ActionScript expression translating variable and field references to their ActionScript names." },
{ "Flash.ActionScript.Import", "Causes an import directive to be emitted in the ActionScript code generated for the current type." },
{ "Flash.ActionScript.Statement", "Emits a block of ActionScript code in the current method translating variable and field references to their ActionScript names." },
{ "Flash.FlashPlayer", "Runtime FlashPlayer support." },
{ "Flash.FlashPlayer.TargetSwfVersion", "Get a string representing the version of the SWF which the current project has been compiled against." },
{ "Flash.FlashPlayer.TargetVersion", "Get a string representing the version of the Flash Player which the current project has been compiled against." },
{ "FlashBuildSubtarget", "Target Flash build player." },
{ "FlashBuildSubtarget.Flash11dot2", "FlashPlayer 11.2 SWF version 15." },
{ "FlashBuildSubtarget.Flash11dot3", "FlashPlayer 11.3 SWF version 16." },
{ "FlashBuildSubtarget.Flash11dot4", "FlashPlayer 11.4 SWF version 17." },
{ "FocusType", "Used by GUIUtility.GetControlID to inform the UnityGUI system if a given control can get keyboard focus." },
{ "FocusType.Keyboard", "This is a proper keyboard control. It can have input focus on all platforms. Used for TextField and TextArea controls." },
{ "FocusType.Native", "This control can get keyboard focus on Windows, but not on Mac. Used for buttons, checkboxes and other \"pressable\" things." },
{ "FocusType.Passive", "This control can never recieve keyboard focus." },
{ "FogMode", "Fog mode to use." },
{ "FogMode.Exponential", "Exponential fog." },
{ "FogMode.ExponentialSquared", "Exponential squared fog (default)." },
{ "FogMode.Linear", "Linear fog." },
{ "Font", "Script interface for font assets." },
{ "Font-characterInfo", "Access an array of all characters contained in the font texture." },
{ "Font-ctor", "Create a new Font." },
{ "Font-dynamic", "Is the font a dynamic font." },
{ "Font-material", "The material used for the font display." },
{ "Font-textureRebuildCallback", "Set a function to be called when the dynamic font texture is rebuilt." },
{ "Font.FontTextureRebuildCallback", "Delegate used for Font.textureRebuildCallback." },
{ "Font.GetCharacterInfo", "Get rendering info for a specific character." },
{ "Font.GetMaxVertsForString", "Returns the maximum number of verts that the text generator may return for a given string." },
{ "Font.HasCharacter", "Does this font have a specific character?" },
{ "Font.RequestCharactersInTexture", "Request characters to be added to the font texture (dynamic fonts only)." },
{ "FontRenderingMode", "Font rendering mode constants for TrueTypeFontImporter." },
{ "FontRenderingMode.HintedRaster", "Use hinted font rendering without anti-aliasing. This is the crispest font rendering option, and may be most readable for small." },
{ "FontRenderingMode.HintedSmooth", "Use Anti-Aliased Font rendering with hinting. This forces character lines to run along pixel boundaries, and generally produces." },
{ "FontRenderingMode.OSDefault", "Use the OS default font rendering mode. This selects either FontRenderingMode.HintedSmooth or." },
{ "FontRenderingMode.Smooth", "Use Anti-Aliased Font rendering. When using dynamic fonts, this is the mode which is fastest in rendering font textures." },
{ "FontStyle", "Font Style applied to GUI Texts, Text Meshes or GUIStyles." },
{ "FontStyle.Bold", "Bold style applied to your texts." },
{ "FontStyle.BoldAndItalic", "Bold and Italic styles applied to your texts." },
{ "FontStyle.Italic", "Italic style applied to your texts." },
{ "FontStyle.Normal", "No special style is applied." },
{ "FontTextureCase", "Texture case constants for TrueTypeFontImporter." },
{ "FontTextureCase.ASCII", "Import basic ASCII character set." },
{ "FontTextureCase.ASCIILowerCase", "Only import lower case ASCII character set." },
{ "FontTextureCase.ASCIIUpperCase", "Only import upper case ASCII character set." },
{ "FontTextureCase.CustomSet", "Custom set of characters." },
{ "FontTextureCase.Dynamic", "Render characters into font texture at runtime as needed." },
{ "FontTextureCase.Unicode", "Import a set of Unicode characters common for latin scripts." },
{ "ForceMode", "Option for how to apply a force using Rigidbody.AddForce." },
{ "ForceMode.Acceleration", "Add a continuous acceleration to the rigidbody, ignoring its mass." },
{ "ForceMode.Force", "Add a continuous force to the rigidbody, using its mass." },
{ "ForceMode.Impulse", "Add an instant force impulse to the rigidbody, using its mass." },
{ "ForceMode.VelocityChange", "Add an instant velocity change to the rigidbody, ignoring its mass." },
{ "ForceMode2D", "Option for how to apply a force using Rigidbody2D.AddForce." },
{ "ForceMode2D.Force", "Add a force to the Rigidbody2D, using its mass." },
{ "ForceMode2D.Impulse", "Add an instant force impulse to the rigidbody2D, using its mass." },
{ "FullScreenMovieControlMode", "Describes options for displaying movie playback controls." },
{ "FullScreenMovieControlMode.CancelOnInput", "Do not display any controls, but cancel movie playback if input occurs." },
{ "FullScreenMovieControlMode.Full", "Display the standard controls for controlling movie playback." },
{ "FullScreenMovieControlMode.Hidden", "Do not display any controls." },
{ "FullScreenMovieControlMode.Minimal", "Display minimal set of controls controlling movie playback." },
{ "FullScreenMovieScalingMode", "Describes scaling modes for displaying movies." },
{ "FullScreenMovieScalingMode.AspectFill", "Scale the movie until the movie fills the entire screen." },
{ "FullScreenMovieScalingMode.AspectFit", "Scale the movie until one dimension fits on the screen exactly." },
{ "FullScreenMovieScalingMode.Fill", "Scale the movie until both dimensions fit the screen exactly." },
{ "FullScreenMovieScalingMode.None", "Do not scale the movie." },
{ "GameObject", "Base class for all entities in Unity scenes." },
{ "GameObject-activeInHierarchy", "Is the GameObject active in the scene?" },
{ "GameObject-activeSelf", "The local active state of this GameObject. (Read Only)" },
{ "GameObject-animation", "The Animation attached to this GameObject (Read Only). (null if there is none attached)." },
{ "GameObject-audio", "The AudioSource attached to this GameObject (Read Only). (null if there is none attached)." },
{ "GameObject-camera", "The Camera attached to this GameObject (Read Only). (null if there is none attached)." },
{ "GameObject-collider", "The Collider attached to this GameObject (Read Only). (null if there is none attached)." },
{ "GameObject-collider2D", "The Collider2D component attached to this object." },
{ "GameObject-constantForce", "The ConstantForce attached to this GameObject (Read Only). (null if there is none attached)." },
{ "GameObject-ctor", "Creates a new game object, named name." },
{ "GameObject-guiText", "The GUIText attached to this GameObject (Read Only). (null if there is none attached)." },
{ "GameObject-guiTexture", "The GUITexture attached to this GameObject (Read Only). (null if there is none attached)." },
{ "GameObject-hingeJoint", "The HingeJoint attached to this GameObject (Read Only). (null if there is none attached)." },
{ "GameObject-isStatic", "Editor only API that specifies if a game object is static." },
{ "GameObject-layer", "The layer the game object is in. A layer is in the range [0...31]." },
{ "GameObject-light", "The Light attached to this GameObject (Read Only). (null if there is none attached)." },
{ "GameObject-networkView", "The NetworkView attached to this GameObject (Read Only). (null if there is none attached)." },
{ "GameObject-particleEmitter", "The ParticleEmitter attached to this GameObject (Read Only). (null if there is none attached)." },
{ "GameObject-particleSystem", "The ParticleSystem attached to this GameObject (Read Only). (null if there is none attached)." },
{ "GameObject-renderer", "The Renderer attached to this GameObject (Read Only). (null if there is none attached)." },
{ "GameObject-rigidbody", "The Rigidbody attached to this GameObject (Read Only). (null if there is none attached)." },
{ "GameObject-rigidbody2D", "The Rigidbody2D component attached to this GameObject. (Read Only)" },
{ "GameObject-tag", "The tag of this game object." },
{ "GameObject-transform", "The Transform attached to this GameObject. (null if there is none attached)." },
{ "GameObject.AddComponent", "Adds a component class named className to the game object." },
{ "GameObject.BroadcastMessage", "Calls the method named methodName on every MonoBehaviour in this game object or any of its children." },
{ "GameObject.CompareTag", "Is this game object tagged with /tag/?" },
{ "GameObject.CreatePrimitive", "Creates a game object with a primitive mesh renderer and appropriate collider." },
{ "GameObject.Find", "Finds a game object by name and returns it." },
{ "GameObject.FindGameObjectsWithTag", "Returns a list of active GameObjects tagged tag. Returns empty array if no GameObject was found." },
{ "GameObject.FindWithTag", "Returns one active GameObject tagged tag. Returns null if no GameObject was found." },
{ "GameObject.GetComponent", "Returns the component of Type type if the game object has one attached, null if it doesn't." },
{ "GameObject.GetComponentInChildren", "Returns the component of Type type in the GameObject or any of its children using depth first search." },
{ "GameObject.GetComponentInParent", "Finds component in the parent." },
{ "GameObject.GetComponents", "Returns all components of Type type in the GameObject." },
{ "GameObject.GetComponentsInChildren", "Returns all components of Type type in the GameObject or any of its children." },
{ "GameObject.GetComponentsInParent", "Returns all components of Type type in the GameObject or any of its parents." },
{ "GameObject.SampleAnimation", "Samples an animation at a given time for any animated properties." },
{ "GameObject.SendMessage", "Calls the method named methodName on every MonoBehaviour in this game object." },
{ "GameObject.SendMessageUpwards", "Calls the method named methodName on every MonoBehaviour in this game object and on every ancestor of the behaviour." },
{ "GameObject.SetActive", "Activates/Deactivates the GameObject." },
{ "GameObjectUtility", "GameObject utility functions." },
{ "GameObjectUtility.AreStaticEditorFlagsSet", "Returns true if the passed in StaticEditorFlags are set." },
{ "GameObjectUtility.GetNavMeshLayer", "Get the navmesh layer for the GameObject." },
{ "GameObjectUtility.GetNavMeshLayerFromName", "Get the navmesh layer from the layer name." },
{ "GameObjectUtility.GetNavMeshLayerNames", "Get all the navmesh layer names." },
{ "GameObjectUtility.GetStaticEditorFlags", "Gets the set StaticEditorFlags." },
{ "GameObjectUtility.SetNavMeshLayer", "Set the navmesh layer for the gameobject." },
{ "GameObjectUtility.SetStaticEditorFlags", "Sets the StaticEditorFlags." },
{ "GenericMenu", "The GenericMenu lets you create a custom context and dropdown menus." },
{ "GenericMenu.AddDisabledItem", "Add a disabled item to the menu." },
{ "GenericMenu.AddItem", "Add an item to the menu." },
{ "GenericMenu.AddSeparator", "Add a seperator item to the menu." },
{ "GenericMenu.DropDown", "Show the menu at the given screen rect." },
{ "GenericMenu.GetItemCount", "Get number of items in the menu." },
{ "GenericMenu.MenuFunction", "Callback function, called when a menu item is selected." },
{ "GenericMenu.MenuFunction2", "Callback function with user data, called when a menu item is selected." },
{ "GenericMenu.ShowAsContext", "Show the menu under the mouse." },
{ "GeometryUtility", "Utility class for common geometric functions." },
{ "GeometryUtility.CalculateFrustumPlanes", "Calculates frustum planes." },
{ "GeometryUtility.TestPlanesAABB", "Returns true if bounds are inside the plane array." },
{ "Gizmos", "Gizmos are used to give visual debugging or setup aids in the scene view." },
{ "Gizmos-color", "Sets the color for the gizmos that will be drawn next." },
{ "Gizmos-matrix", "Set the gizmo matrix used to draw all gizmos." },
{ "Gizmos.DrawCube", "Draw a solid box with center and size." },
{ "Gizmos.DrawFrustum", "Draw a camera frustum using the currently set Gizmos.matrix for it's location and rotation." },
{ "Gizmos.DrawGUITexture", "Draw a texture in the scene." },
{ "Gizmos.DrawIcon", "Draw an icon at a position in the scene view." },
{ "Gizmos.DrawLine", "Draws a line starting at from towards to." },
{ "Gizmos.DrawRay", "Draws a ray starting at from to from + direction." },
{ "Gizmos.DrawSphere", "Draws a solid sphere with center and radius." },
{ "Gizmos.DrawWireCube", "Draw a wireframe box with center and size." },
{ "Gizmos.DrawWireSphere", "Draws a wireframe sphere with center and radius." },
{ "GizmoType", "Determines how a gizmo is drawn or picked in the Unity editor." },
{ "GizmoType.Active", "Draw the gizmo if it is active (shown in the inspector)." },
{ "GizmoType.NotSelected", "Draw the gizmo if it is not selected and also no parent/ancestor object is selected." },
{ "GizmoType.Pickable", "The gizmo can be picked in the editor." },
{ "GizmoType.Selected", "Draw the gizmo if it is selected." },
{ "GizmoType.SelectedOrChild", "Draw the gizmo if it is selected or a child of the selection." },
{ "GL", "Low-level graphics library." },
{ "GL-modelview", "The current modelview matrix." },
{ "GL-wireframe", "Should rendering be done in wireframe?" },
{ "GL.Begin", "Begin drawing 3D primitives." },
{ "GL.Clear", "Clear the current render buffer." },
{ "GL.ClearWithSkybox", "Clear the current render buffer with camera's skybox." },
{ "GL.Color", "Sets current vertex color." },
{ "GL.End", "End drawing 3D primitives." },
{ "GL.GetGPUProjectionMatrix", "Compute GPU projection matrix from camera's projection matrix." },
{ "GL.InvalidateState", "Invalidate the internally cached renderstates." },
{ "GL.IssuePluginEvent", "Send a user-defined event to a native code plugin." },
{ "GL.LINES", "Mode for GL.Begin: draw lines." },
{ "GL.LoadIdentity", "Load the identity matrix to the current modelview matrix." },
{ "GL.LoadOrtho", "Helper function to set up an ortho perspective transform." },
{ "GL.LoadPixelMatrix", "Setup a matrix for pixel-correct rendering." },
{ "GL.LoadProjectionMatrix", "Load an arbitrary matrix to the current projection matrix." },
{ "GL.MultiTexCoord", "Sets current texture coordinate (v.x,v.y,v.z) to the actual texture unit." },
{ "GL.MultiTexCoord2", "Sets current texture coordinate (x,y) for the actual texture unit." },
{ "GL.MultiTexCoord3", "Sets current texture coordinate (x,y,z) to the actual texture unit." },
{ "GL.MultMatrix", "Multiplies the current modelview matrix with the one specified." },
{ "GL.PopMatrix", "Restores both projection and modelview matrices off the top of the matrix stack." },
{ "GL.PushMatrix", "Saves both projection and modelview matrices to the matrix stack." },
{ "GL.QUADS", "Mode for GL.Begin: draw quads." },
{ "GL.SetRevertBackfacing", "Select whether to invert the backface culling (true) or not (false)." },
{ "GL.TexCoord", "Sets current texture coordinate (v.x,v.y,v.z) for all texture units." },
{ "GL.TexCoord2", "Sets current texture coordinate (x,y) for all texture units." },
{ "GL.TexCoord3", "Sets current texture coordinate (x,y,z) for all texture units." },
{ "GL.TRIANGLE_STRIP", "Mode for GL.Begin: draw triangle strip." },
{ "GL.TRIANGLES", "Mode for GL.Begin: draw triangles." },
{ "GL.Vertex", "Submit a vertex." },
{ "GL.Vertex3", "Submit a vertex." },
{ "GL.Viewport", "Set the rendering viewport." },
{ "Gradient", "Gradient used for animating colors." },
{ "Gradient-alphaKeys", "All alpha keys defined in the gradient." },
{ "Gradient-colorKeys", "All color keys defined in the gradient." },
{ "Gradient-ctor", "Create a new Gradient object." },
{ "Gradient.Evaluate", "Calculate color at a given time." },
{ "Gradient.SetKeys", "Setup Gradient with an array of color keys and alpha keys." },
{ "GradientAlphaKey", "Alpha key used by Gradient." },
{ "GradientAlphaKey-alpha", "Alpha alpha of key." },
{ "GradientAlphaKey-ctor", "Gradient alpha key." },
{ "GradientAlphaKey-time", "Time of the key (0 - 1)." },
{ "GradientColorKey", "Color key used by Gradient." },
{ "GradientColorKey-color", "Color of key." },
{ "GradientColorKey-ctor", "Gradient color key." },
{ "GradientColorKey-time", "Time of the key (0 - 1)." },
{ "Graphics", "Raw interface to Unity's drawing functions." },
{ "Graphics-activeColorBuffer", "Currently active color buffer (Read Only)." },
{ "Graphics-activeDepthBuffer", "Currently active depth buffer (Read Only)." },
{ "Graphics.Blit", "Copies source texture into destination render texture." },
{ "Graphics.BlitMultiTap", "Copies source texture into destination, for multi-tap shader." },
{ "Graphics.ClearRandomWriteTargets", "Clear random write targets for DX11 pixel shaders." },
{ "Graphics.DrawMesh", "Draw a mesh." },
{ "Graphics.DrawMeshNow", "Draw a mesh immediately." },
{ "Graphics.DrawProcedural", "Draws a fully procedural geometry on the GPU." },
{ "Graphics.DrawProceduralIndirect", "Draws a fully procedural geometry on the GPU." },
{ "Graphics.DrawTexture", "Draw a texture in screen coordinates." },
{ "Graphics.SetRandomWriteTarget", "Set random write target for DX11 pixel shaders." },
{ "Graphics.SetRenderTarget", "Sets current render target." },
{ "GUI", "The GUI class is the interface for Unity's GUI with manual positioning." },
{ "GUI-backgroundColor", "Global tinting color for all background elements rendered by the GUI." },
{ "GUI-changed", "Returns true if any controls changed the value of the input data." },
{ "GUI-color", "Global tinting color for the GUI." },
{ "GUI-contentColor", "Tinting color for all text rendered by the GUI." },
{ "GUI-depth", "The sorting depth of the currently executing GUI behaviour." },
{ "GUI-enabled", "Is the GUI enabled?" },
{ "GUI-matrix", "The GUI transform matrix." },
{ "GUI-skin", "The global skin to use." },
{ "GUI-tooltip", "The tooltip of the control the mouse is currently over, or which has keyboard focus. (Read Only)." },
{ "GUI.BeginGroup", "Begin a group. Must be matched with a call to GL.EndGroup." },
{ "GUI.BeginScrollView", "Begin a scrolling view inside your GUI." },
{ "GUI.Box", "Make a graphical box." },
{ "GUI.BringWindowToBack", "Bring a specific window to back of the floating windows." },
{ "GUI.BringWindowToFront", "Bring a specific window to front of the floating windows." },
{ "GUI.Button", "Make a single press button. The user clicks them and something happens immediately." },
{ "GUI.DragWindow", "Make a window draggable." },
{ "GUI.DrawTexture", "Draw a texture within a rectangle." },
{ "GUI.DrawTextureWithTexCoords", "Draw a texture within a rectangle with the given texture coordinates. Use this function for clipping or tiling the image within the given rectangle." },
{ "GUI.EndGroup", "End a group." },
{ "GUI.EndScrollView", "Ends a scrollview started with a call to BeginScrollView." },
{ "GUI.FocusControl", "Move keyboard focus to a named control." },
{ "GUI.FocusWindow", "Make a window become the active window." },
{ "GUI.GetNameOfFocusedControl", "Get the name of named control that has focus." },
{ "GUI.HorizontalScrollbar", "Make a horizontal scrollbar. Scrollbars are what you use to scroll through a document. Most likely, you want to use scrollViews instead." },
{ "GUI.HorizontalSlider", "A horizontal slider the user can drag to change a value between a min and a max." },
{ "GUI.Label", "Make a text or texture label on screen." },
{ "GUI.ModalWindow", "Show a Modal Window." },
{ "GUI.PasswordField", "Make a text field where the user can enter a password." },
{ "GUI.RepeatButton", "Make a button that is active as long as the user holds it down." },
{ "GUI.ScrollTo", "Scrolls all enclosing scrollviews so they try to make position visible." },
{ "GUI.SelectionGrid", "Make a grid of buttons." },
{ "GUI.SetNextControlName", "Set the name of the next control." },
{ "GUI.TextArea", "Make a Multi-line text area where the user can edit a string." },
{ "GUI.TextField", "Make a single-line text field where the user can edit a string." },
{ "GUI.Toggle", "Make an on/off toggle button." },
{ "GUI.Toolbar", "Make a toolbar." },
{ "GUI.UnfocusWindow", "Remove focus from all windows." },
{ "GUI.VerticalScrollbar", "Make a vertical scrollbar. Scrollbars are what you use to scroll through a document. Most likely, you want to use scrollViews instead." },
{ "GUI.VerticalSlider", "A vertical slider the user can drag to change a value between a min and a max." },
{ "GUI.Window", "Make a popup window." },
{ "GUI.WindowFunction", "Callback to draw GUI within a window (used with GUI.Window)." },
{ "GUIContent", "The contents of a GUI element." },
{ "GUIContent-ctor", "Constructor for GUIContent in all shapes and sizes." },
{ "GUIContent-image", "The icon image contained." },
{ "GUIContent-none", "Shorthand for empty content." },
{ "GUIContent-text", "The text contained." },
{ "GUIContent-tooltip", "The tooltip of this element." },
{ "GUIDrawer", "Base class for PropertyDrawer and DecoratorDrawer." },
{ "GUIElement", "Base class for images & text strings displayed in a GUI." },
{ "GUIElement.GetScreenRect", "Returns bounding rectangle of GUIElement in screen coordinates." },
{ "GUIElement.HitTest", "Is a point on screen inside the element." },
{ "GUILayer", "Component added to a camera to make it render 2D GUI elements." },
{ "GUILayer.HitTest", "Get the GUI element at a specific screen position." },
{ "GUILayout", "The GUILayout class is the interface for Unity gui with automatic layout." },
{ "GUILayout.BeginArea", "Begin a GUILayout block of GUI controls in a fixed screen area." },
{ "GUILayout.BeginHorizontal", "Begin a Horizontal control group." },
{ "GUILayout.BeginScrollView", "Begin an automatically laid out scrollview." },
{ "GUILayout.BeginVertical", "Begin a vertical control group." },
{ "GUILayout.Box", "Make an auto-layout box." },
{ "GUILayout.Button", "Make a single press button. The user clicks them and something happens immediately." },
{ "GUILayout.EndArea", "Close a GUILayout block started with BeginArea." },
{ "GUILayout.EndHorizontal", "Close a group started with BeginHorizontal." },
{ "GUILayout.EndScrollView", "End a scroll view begun with a call to BeginScrollView." },
{ "GUILayout.EndVertical", "Close a group started with BeginVertical." },
{ "GUILayout.ExpandHeight", "Option passed to a control to allow or disallow vertical expansion." },
{ "GUILayout.ExpandWidth", "Option passed to a control to allow or disallow horizontal expansion." },
{ "GUILayout.FlexibleSpace", "Insert a flexible space element." },
{ "GUILayout.Height", "Option passed to a control to give it an absolute height." },
{ "GUILayout.HorizontalScrollbar", "Make a horiztonal scrollbar." },
{ "GUILayout.HorizontalSlider", "A horizontal slider the user can drag to change a value between a min and a max." },
{ "GUILayout.Label", "Make an auto-layout label." },
{ "GUILayout.MaxHeight", "Option passed to a control to specify a maximum height." },
{ "GUILayout.MaxWidth", "Option passed to a control to specify a maximum width." },
{ "GUILayout.MinHeight", "Option passed to a control to specify a minimum height." },
{ "GUILayout.MinWidth", "Option passed to a control to specify a minimum width." },
{ "GUILayout.PasswordField", "Make a text field where the user can enter a password." },
{ "GUILayout.RepeatButton", "Make a repeating button. The button returns true as long as the user holds down the mouse." },
{ "GUILayout.SelectionGrid", "Make a Selection Grid." },
{ "GUILayout.Space", "Insert a space in the current layout group." },
{ "GUILayout.TextArea", "Make a multi-line text field where the user can edit a string." },
{ "GUILayout.TextField", "Make a single-line text field where the user can edit a string." },
{ "GUILayout.Toggle", "Make an on/off toggle button." },
{ "GUILayout.Toolbar", "Make a toolbar." },
{ "GUILayout.VerticalScrollbar", "Make a vertical scrollbar." },
{ "GUILayout.VerticalSlider", "A vertical slider the user can drag to change a value between a min and a max." },
{ "GUILayout.Width", "Option passed to a control to give it an absolute width." },
{ "GUILayout.Window", "Make a popup window that layouts its contents automatically." },
{ "GUILayoutOption", "Class internally used to pass layout options into GUILayout functions. You don't use these directly, but construct them with the layouting functions in the GUILayout class." },
{ "GUILayoutUtility", "Utility functions for implementing and extending the GUILayout class." },
{ "GUILayoutUtility.GetAspectRect", "Reserve layout space for a rectangle with a specific aspect ratio." },
{ "GUILayoutUtility.GetLastRect", "Get the rectangle last used by GUILayout for a control." },
{ "GUILayoutUtility.GetRect", "Reserve layout space for a rectangle for displaying some contents with a specific style." },
{ "GUISettings", "General settings for how the GUI behaves." },
{ "GUISettings-cursorColor", "The color of the cursor in text fields." },
{ "GUISettings-cursorFlashSpeed", "The speed of text field cursor flashes." },
{ "GUISettings-doubleClickSelectsWord", "Should double-clicking select words in text fields." },
{ "GUISettings-selectionColor", "The color of the selection rect in text fields." },
{ "GUISettings-tripleClickSelectsLine", "Should triple-clicking select whole text in text fields." },
{ "GUISkin", "Defines how GUI looks and behaves." },
{ "GUISkin-box", "Style used by default for GUI.Box controls." },
{ "GUISkin-button", "Style used by default for GUI.Button controls." },
{ "GUISkin-customStyles", "Array of GUI styles for specific needs." },
{ "GUISkin-font", "The default font to use for all styles." },
{ "GUISkin-horizontalScrollbar", "Style used by default for the background part of GUI.HorizontalScrollbar controls." },
{ "GUISkin-horizontalScrollbarLeftButton", "Style used by default for the left button on GUI.HorizontalScrollbar controls." },
{ "GUISkin-horizontalScrollbarRightButton", "Style used by default for the right button on GUI.HorizontalScrollbar controls." },
{ "GUISkin-horizontalScrollbarThumb", "Style used by default for the thumb that is dragged in GUI.HorizontalScrollbar controls." },
{ "GUISkin-horizontalSlider", "Style used by default for the background part of GUI.HorizontalSlider controls." },
{ "GUISkin-horizontalSliderThumb", "Style used by default for the thumb that is dragged in GUI.HorizontalSlider controls." },
{ "GUISkin-label", "Style used by default for GUI.Label controls." },
{ "GUISkin-scrollView", "Style used by default for the background of ScrollView controls (see GUI.BeginScrollView)." },
{ "GUISkin-settings", "Generic settings for how controls should behave with this skin." },
{ "GUISkin-textArea", "Style used by default for GUI.TextArea controls." },
{ "GUISkin-textField", "Style used by default for GUI.TextField controls." },
{ "GUISkin-toggle", "Style used by default for GUI.Toggle controls." },
{ "GUISkin-verticalScrollbar", "Style used by default for the background part of GUI.VerticalScrollbar controls." },
{ "GUISkin-verticalScrollbarDownButton", "Style used by default for the down button on GUI.VerticalScrollbar controls." },
{ "GUISkin-verticalScrollbarThumb", "Style used by default for the thumb that is dragged in GUI.VerticalScrollbar controls." },
{ "GUISkin-verticalScrollbarUpButton", "Style used by default for the up button on GUI.VerticalScrollbar controls." },
{ "GUISkin-verticalSlider", "Style used by default for the background part of GUI.VerticalSlider controls." },
{ "GUISkin-verticalSliderThumb", "Style used by default for the thumb that is dragged in GUI.VerticalSlider controls." },
{ "GUISkin-window", "Style used by default for Window controls (SA GUI.Window)." },
{ "GUISkin.FindStyle", "Try to search for a GUIStyle. This functions returns NULL and does not give an error." },
{ "GUISkin.GetStyle", "Get a named GUIStyle." },
{ "GUIStyle", "Styling information for GUI elements." },
{ "GUIStyle-active", "Rendering settings for when the control is pressed down." },
{ "GUIStyle-alignment", "Text alignment." },
{ "GUIStyle-border", "The borders of all background images." },
{ "GUIStyle-clipping", "What to do when the contents to be rendered is too large to fit within the area given." },
{ "GUIStyle-contentOffset", "Pixel offset to apply to the content of this GUIstyle." },
{ "GUIStyle-ctor", "Constructor for empty GUIStyle." },
{ "GUIStyle-fixedHeight", "If non-0, any GUI elements rendered with this style will have the height specified here." },
{ "GUIStyle-fixedWidth", "If non-0, any GUI elements rendered with this style will have the width specified here." },
{ "GUIStyle-focused", "Rendering settings for when the element has keyboard focus." },
{ "GUIStyle-font", "The font to use for rendering. If null, the default font for the current GUISkin is used instead." },
{ "GUIStyle-fontSize", "The font size to use (for dynamic fonts)." },
{ "GUIStyle-fontStyle", "The font style to use (for dynamic fonts)." },
{ "GUIStyle-hover", "Rendering settings for when the mouse is hovering over the control." },
{ "GUIStyle-imagePosition", "How image and text of the GUIContent is combined." },
{ "GUIStyle-lineHeight", "The height of one line of text with this style, measured in pixels. (Read Only)" },
{ "GUIStyle-margin", "The margins between elements rendered in this style and any other GUI elements." },
{ "GUIStyle-name", "The name of this GUIStyle. Used for getting them based on name." },
{ "GUIStyle-none", "Shortcut for an empty GUIStyle." },
{ "GUIStyle-normal", "Rendering settings for when the component is displayed normally." },
{ "GUIStyle-onActive", "Rendering settings for when the element is turned on and pressed down." },
{ "GUIStyle-onFocused", "Rendering settings for when the element has keyboard and is turned on." },
{ "GUIStyle-onHover", "Rendering settings for when the control is turned on and the mouse is hovering it." },
{ "GUIStyle-onNormal", "Rendering settings for when the control is turned on." },
{ "GUIStyle-operator_string", "Get a named GUI style from the current skin." },
{ "GUIStyle-overflow", "Extra space to be added to the background image." },
{ "GUIStyle-padding", "Space from the edge of GUIStyle to the start of the contents." },
{ "GUIStyle-richText", "Enable HTML-style tags for Text Formatting Markup." },
{ "GUIStyle-stretchHeight", "Can GUI elements of this style be stretched vertically for better layout?" },
{ "GUIStyle-stretchWidth", "Can GUI elements of this style be stretched horizontally for better layouting?" },
{ "GUIStyle-wordWrap", "Should the text be wordwrapped?" },
{ "GUIStyle.CalcHeight", "How tall this element will be when rendered with content and a specific width." },
{ "GUIStyle.CalcMinMaxWidth", "Calculate the minimum and maximum widths for this style rendered with content." },
{ "GUIStyle.CalcScreenSize", "Calculate the size of an element formatted with this style, and a given space to content." },
{ "GUIStyle.CalcSize", "Calculate the size of a some content if it is rendered with this style." },
{ "GUIStyle.Draw", "Draw this GUIStyle on to the screen, internal version." },
{ "GUIStyle.DrawCursor", "Draw this GUIStyle with selected content." },
{ "GUIStyle.DrawWithTextSelection", "Draw this GUIStyle with selected content." },
{ "GUIStyle.GetCursorPixelPosition", "Get the pixel position of a given string index." },
{ "GUIStyle.GetCursorStringIndex", "Get the cursor position (indexing into contents.text) when the user clicked at cursorPixelPosition." },
{ "GUIStyleState", "Specialized values for the given states used by GUIStyle objects." },
{ "GUIStyleState-background", "The background image used by GUI elements in this given state." },
{ "GUIStyleState-textColor", "The text color used by GUI elements in this state." },
{ "GUIText", "A text string displayed in a GUI." },
{ "GUIText-alignment", "The alignment of the text." },
{ "GUIText-anchor", "The anchor of the text." },
{ "GUIText-color", "The color used to render the text." },
{ "GUIText-font", "The font used for the text." },
{ "GUIText-fontSize", "The font size to use (for dynamic fonts)." },
{ "GUIText-fontStyle", "The font style to use (for dynamic fonts)." },
{ "GUIText-lineSpacing", "The line spacing multiplier." },
{ "GUIText-material", "The Material to use for rendering." },
{ "GUIText-pixelOffset", "The pixel offset of the text." },
{ "GUIText-richText", "Enable HTML-style tags for Text Formatting Markup." },
{ "GUIText-tabSize", "The tab width multiplier." },
{ "GUIText-text", "The text to display." },
{ "GUITexture", "A texture image used in a 2D GUI." },
{ "GUITexture-border", "The border defines the number of pixels from the edge that are not affected by scale." },
{ "GUITexture-color", "The color of the GUI texture." },
{ "GUITexture-pixelInset", "Pixel inset used for pixel adjustments for size and position." },
{ "GUITexture-texture", "The texture used for drawing." },
{ "GUIUtility", "Utility class for making new GUI controls." },
{ "GUIUtility-hasModalWindow", "A global property, which is true if a ModalWindow is being displayed, false otherwise." },
{ "GUIUtility-hotControl", "The controlID of the current hot control." },
{ "GUIUtility-keyboardControl", "The controlID of the control that has keyboard focus." },
{ "GUIUtility.GetControlID", "Get a unique ID for a control." },
{ "GUIUtility.GetStateObject", "Get a state object from a controlID." },
{ "GUIUtility.GUIToScreenPoint", "Convert a point from GUI position to screen space." },
{ "GUIUtility.QueryStateObject", "Get an existing state object from a controlID." },
{ "GUIUtility.RotateAroundPivot", "Helper function to rotate the GUI around a point." },
{ "GUIUtility.ScaleAroundPivot", "Helper function to scale the GUI around a point." },
{ "GUIUtility.ScreenToGUIPoint", "Convert a point from screen space to GUI position." },
{ "Gyroscope", "Interface into the Gyroscope." },
{ "Gyroscope-attitude", "Returns the attitude (ie, orientation in space) of the device." },
{ "Gyroscope-enabled", "Sets or retrieves the enabled status of this gyroscope." },
{ "Gyroscope-gravity", "Returns the gravity acceleration vector expressed in the device's reference frame." },
{ "Gyroscope-rotationRate", "Returns rotation rate as measured by the device's gyroscope." },
{ "Gyroscope-rotationRateUnbiased", "Returns unbiased rotation rate as measured by the device's gyroscope." },
{ "Gyroscope-updateInterval", "Sets or retrieves gyroscope interval in seconds." },
{ "Gyroscope-userAcceleration", "Returns the acceleration that the user is giving to the device." },
{ "Handheld", "Interface into functionality unique to handheld devices." },
{ "Handheld-use32BitDisplayBuffer", "Determines whether or not a 32-bit display buffer will be used." },
{ "Handheld.GetActivityIndicatorStyle", "Gets the current activity indicator style." },
{ "Handheld.PlayFullScreenMovie", "Plays a full-screen movie (pro only feature)." },
{ "Handheld.SetActivityIndicatorStyle", "Sets the desired activity indicator style." },
{ "Handheld.StartActivityIndicator", "Starts os activity indicator." },
{ "Handheld.StopActivityIndicator", "Stops os activity indicator." },
{ "Handheld.Vibrate", "Triggers device vibration." },
{ "Handles", "Custom 3D GUI controls and drawing in the scene view." },
{ "Handles-centerColor", "Color to use for handles that represent the center of something." },
{ "Handles-color", "Colors of the handles." },
{ "Handles-currentCamera", "Setup viewport and stuff for a current camera." },
{ "Handles-inverseMatrix", "The inverse of the matrix for all handle operations." },
{ "Handles-lighting", "Are handles lit?" },
{ "Handles-matrix", "Matrix for all handle operations." },
{ "Handles-secondaryColor", "Soft color to use for for general things." },
{ "Handles-selectedColor", "Color to use for the currently active handle." },
{ "Handles-xAxisColor", "Color to use for handles that manipulates the X coordinate of something." },
{ "Handles-yAxisColor", "Color to use for handles that manipulates the Y coordinate of something." },
{ "Handles-zAxisColor", "Color to use for handles that manipulates the Z coordinate of something." },
{ "Handles.ArrowCap", "Draw an arrow like those used by the move tool." },
{ "Handles.BeginGUI", "Begin a 2D GUI block inside the 3D handle GUI." },
{ "Handles.Button", "Make a 3D Button." },
{ "Handles.CircleCap", "Draw a camera-facing Circle. Pass this into handle functions." },
{ "Handles.ClearCamera", "Clears the camera." },
{ "Handles.ConeCap", "Draw a Cone. Pass this into handle functions." },
{ "Handles.CubeCap", "Draw a cube. Pass this into handle functions." },
{ "Handles.CylinderCap", "Draw a Cylinder. Pass this into handle functions." },
{ "Handles.Disc", "Make a 3D disc that can be dragged with the mouse." },
{ "Handles.DotCap", "Draw a camera-facing dot. Pass this into handle functions." },
{ "Handles.DrawAAPolyLine", "Draw anti-aliased line specified with point array and width." },
{ "Handles.DrawBezier", "Draw textured bezier line through start and end points with the given tangents. To get an anti-aliased effect use a texture that is 1x2 pixels with one transparent white pixel and one opaque white pixel. The bezier curve will be swept using this texture." },
{ "Handles.DrawCamera", "Draws a camera inside a rectangle." },
{ "Handles.DrawCapFunction", "The function to use for drawing the handle e.g. Handles.RectangleCap." },
{ "Handles.DrawDottedLine", "Draw a dotted line from p1 to p2." },
{ "Handles.DrawLine", "Draw a line from p1 to p2." },
{ "Handles.DrawPolyLine", "Draw a line going through the list of all points." },
{ "Handles.DrawSolidArc", "Draw a circular sector (pie piece) in 3D space." },
{ "Handles.DrawSolidDisc", "Draw a solid flat disc in 3D space." },
{ "Handles.DrawSolidRectangleWithOutline", "Draw a solid outlined rectangle in 3D space." },
{ "Handles.DrawWireArc", "Draw a circular arc in 3D space." },
{ "Handles.DrawWireDisc", "Draw the outline of a flat disc in 3D space." },
{ "Handles.EndGUI", "End a 2D GUI block and get back to the 3D handle GUI." },
{ "Handles.FreeMoveHandle", "Make an unconstrained movement handle." },
{ "Handles.FreeRotateHandle", "Make an unconstrained rotation handle." },
{ "Handles.GetMainGameViewSize", "Get the width and height of the main game view." },
{ "Handles.Label", "Make a text label positioned in 3D space." },
{ "Handles.PositionHandle", "Make a 3D Scene view position handle." },
{ "Handles.RadiusHandle", "Make a Scene view radius handle." },
{ "Handles.RotationHandle", "Make a Scene view rotation handle." },
{ "Handles.ScaleHandle", "Make a Scene view scale handle." },
{ "Handles.ScaleSlider", "Make a directional scale slider." },
{ "Handles.ScaleValueHandle", "Make a single-float draggable handle." },
{ "Handles.SelectionFrame", "Draw a camera facing selection frame." },
{ "Handles.SetCamera", "Set the current camera so all Handles and Gizmos are draw with its settings." },
{ "Handles.Slider", "Make a 3D slider." },
{ "Handles.Slider2D", "Slide a handle in a 2D plane." },
{ "Handles.SnapValue", "Rounds the value val to the closest multiple of snap (snap can only be posiive)." },
{ "Handles.SphereCap", "Draw a Sphere. Pass this into handle functions." },
{ "HandleUtility", "Helper functions for Scene View style 3D GUI." },
{ "HandleUtility-acceleration", "Get standard acceleration for dragging values (Read Only)." },
{ "HandleUtility-niceMouseDelta", "Get nice mouse delta to use for dragging a float value (Read Only)." },
{ "HandleUtility-niceMouseDeltaZoom", "Get nice mouse delta to use for zooming (Read Only)." },
{ "HandleUtility.AddControl", "Record a distance measurement from a handle." },
{ "HandleUtility.AddDefaultControl", "Add the ID for a default control. This will be picked if nothing else is." },
{ "HandleUtility.CalcLineTranslation", "Map a mouse drag onto a movement along a line in 3D space." },
{ "HandleUtility.ClosestPointToArc", "Get the point on an arc (in 3D space) which is closest to the current mouse position." },
{ "HandleUtility.ClosestPointToDisc", "Get the point on an disc (in 3D space) which is closest to the current mouse position." },
{ "HandleUtility.ClosestPointToPolyLine", "Get the point on a polyline (in 3D space) which is closest to the current mouse position." },
{ "HandleUtility.DistancePointBezier", "Calculate distance between a point and a Bezier curve." },
{ "HandleUtility.DistancePointLine", "Calculate distance between a point and a line." },
{ "HandleUtility.DistancePointToLine", "Distance from a point p in 2d to a line defined by two points a and b." },
{ "HandleUtility.DistancePointToLineSegment", "Distance from a point p in 2d to a line segment defined by two points a and b." },
{ "HandleUtility.DistanceToArc", "Pixel distance from mouse pointer to a 3D section of a disc." },
{ "HandleUtility.DistanceToCircle", "Pixel distance from mouse pointer to camera facing circle." },
{ "HandleUtility.DistanceToDisc", "Pixel distance from mouse pointer to a 3D disc." },
{ "HandleUtility.DistanceToLine", "Pixel distance from mouse pointer to line." },
{ "HandleUtility.DistanceToPolyLine", "Pixel distance from mouse pointer to a polyline." },
{ "HandleUtility.DistanceToRectangle", "Pixel distance from mouse pointer to a rectangle on screen." },
{ "HandleUtility.GetHandleSize", "Get world space size of a manipulator handle at given position." },
{ "HandleUtility.GUIPointToWorldRay", "Convert 2D GUI position to a world space ray." },
{ "HandleUtility.PickGameObject", "Pick game object closest to specified position." },
{ "HandleUtility.PickRectObjects", "Pick GameObjects that lie within a specified screen rectangle." },
{ "HandleUtility.PointOnLineParameter", "Returns the parameter for the projection of the point on the given line." },
{ "HandleUtility.PopCamera", "Retrieve all camera settings." },
{ "HandleUtility.ProjectPointLine", "Project point onto a line." },
{ "HandleUtility.PushCamera", "Store all camera settings." },
{ "HandleUtility.RaySnap", "Casts ray against the scene and report if an object lies in its path." },
{ "HandleUtility.Repaint", "Repaint the current view." },
{ "HandleUtility.WorldPointToSizedRect", "Calculate a rectangle to display a 2D GUI element near a projected point in 3D space." },
{ "HandleUtility.WorldToGUIPoint", "Convert world space point to a 2D GUI position." },
{ "Hashtable", "You can use a Hashtable to store key+value pairs." },
{ "Hashtable.Add", "Adds an element with the specified key and value into the Hashtable." },
{ "Hashtable.Clear", "Count is set to zero, and references to other objects from elements of the collection are also released." },
{ "Hashtable.Contains", "Determines whether the Hashtable contains a specific key." },
{ "Hashtable.ContainsKey", "Determines whether the Hashtable contains a specific key." },
{ "Hashtable.ContainsValue", "Determines whether the Hashtable contains a specific value." },
{ "Hashtable.Count", "Returns how many elements are in the hashtable." },
{ "Hashtable.Remove", "Removes the element with the specified key from the Hashtable." },
{ "HeaderAttribute", "Use this PropertyAttribute to add a header above some fields in the Inspector." },
{ "HeaderAttribute-ctor", "Add a header above some fields in the Inspector." },
{ "HeaderAttribute-header", "The header text." },
{ "Help", "Helper class to access Unity documentation." },
{ "Help.BrowseURL", "Open url in the default web browser." },
{ "Help.HasHelpForObject", "Is there a help page for this object?" },
{ "Help.ShowHelpForObject", "Show help page for this object." },
{ "Help.ShowHelpPage", "Show a help page." },
{ "HideFlags", "Bit mask that controls object destruction and visibility in inspectors." },
{ "HideFlags.DontSave", "The object will not be saved to the scene. It will not be destroyed when a new scene is loaded." },
{ "HideFlags.HideAndDontSave", "A combination of not shown in the hierarchy and not saved to to scenes." },
{ "HideFlags.HideInHierarchy", "The object will not appear in the hierarchy." },
{ "HideFlags.HideInInspector", "It is not possible to view it in the inspector." },
{ "HideFlags.None", "A normal, visible object. This is the default." },
{ "HideFlags.NotEditable", "The object is not be editable in the inspector." },
{ "HideInInspector", "Makes a variable not show up in the inspector but be serialized." },
{ "Highlighter", "Use this class to highlight elements in the editor for use in in-editor tutorials and similar." },
{ "Highlighter-active", "Is there currently an active highlight?" },
{ "Highlighter-activeRect", "The rect in screenspace of the current active highlight." },
{ "Highlighter-activeText", "The text of the current active highlight." },
{ "Highlighter-activeVisible", "Is the current active highlight visible yet?" },
{ "Highlighter.Highlight", "Highlights an element in the editor." },
{ "Highlighter.HighlightIdentifier", "Call this method to create an identifiable rect that the Highlighter can find." },
{ "Highlighter.Stop", "Stops the active highlight." },
{ "HighlightSearchMode", "Used to specify how to find a given element in the editor to highlight." },
{ "HighlightSearchMode.Auto", "Highlights the first element found using any of the search modes." },
{ "HighlightSearchMode.Content", "Highlights an element containing text using the text as identifier." },
{ "HighlightSearchMode.Identifier", "Highlights an element with a given identifier text." },
{ "HighlightSearchMode.None", "Highlights nothing." },
{ "HighlightSearchMode.PrefixLabel", "Highlights an entire editor control using its label text as identifier." },
{ "HingeJoint", "The HingeJoint groups together 2 rigid bodies, constraining them to move like connected by a hinge." },
{ "HingeJoint-angle", "The current angle in degrees of the joint relative to its rest position. (Read Only)" },
{ "HingeJoint-limits", "Limit of angular rotation on the hinge joint." },
{ "HingeJoint-motor", "The motor will apply a force up to a maximum force to achieve the target velocity in degrees per second." },
{ "HingeJoint-spring", "The spring attempts to reach a target angle by adding spring and damping forces." },
{ "HingeJoint-useLimits", "Enables the joint's limits." },
{ "HingeJoint-useMotor", "Enables the joint's motor." },
{ "HingeJoint-useSpring", "Enables the joint's spring." },
{ "HingeJoint-velocity", "The angular velocity of the joint in degrees per second." },
{ "HingeJoint2D", "Joint that allows a Rigidbody2D object to rotate around a point in space or a point on another object." },
{ "HingeJoint2D-jointAngle", "The current joint angle with respect to the reference angle." },
{ "HingeJoint2D-jointSpeed", "The current joint speed." },
{ "HingeJoint2D-limits", "Limit of angular rotation on the joint." },
{ "HingeJoint2D-limitState", "Gets the state of the joint limit." },
{ "HingeJoint2D-motor", "Parameters for the motor force applied to the joint." },
{ "HingeJoint2D-referenceAngle", "The angle referenced between the two bodies used as the constraint for the joint." },
{ "HingeJoint2D-useLimits", "Should limits be placed on the range of rotation?" },
{ "HingeJoint2D-useMotor", "Should the joint be rotated automatically by a motor torque?" },
{ "HingeJoint2D.GetMotorTorque", "Gets the motor torque of the joint given the specified timestep." },
{ "HingeJoint2D.GetReactionForce", "Gets the reaction force of the joint given the specified timestep." },
{ "HingeJoint2D.GetReactionTorque", "Gets the reaction torque of the joint given the specified timestep." },
{ "HostData", "This is the data structure for holding individual host information." },
{ "HostData-comment", "A miscellaneous comment (can hold data)." },
{ "HostData-connectedPlayers", "Currently connected players." },
{ "HostData-gameName", "The name of the game (like John Doe's Game)." },
{ "HostData-gameType", "The type of the game (like \"MyUniqueGameType\")." },
{ "HostData-guid", "The GUID of the host, needed when connecting with NAT punchthrough." },
{ "HostData-ip", "Server IP address." },
{ "HostData-passwordProtected", "Does the server require a password?" },
{ "HostData-playerLimit", "Maximum players limit." },
{ "HostData-port", "Server port." },
{ "HostData-useNat", "Does this server require NAT punchthrough?" },
{ "HumanBodyBones", "Human Body Bones." },
{ "HumanBodyBones.Chest", "This is the Chest bone." },
{ "HumanBodyBones.Head", "This is the Head bone." },
{ "HumanBodyBones.Hips", "This is the Hips bone." },
{ "HumanBodyBones.Jaw", "This is the Jaw bone." },
{ "HumanBodyBones.LastBone", "This is the Last bone index delimiter." },
{ "HumanBodyBones.LeftEye", "This is the Left Eye bone." },
{ "HumanBodyBones.LeftFoot", "This is the Left Ankle bone." },
{ "HumanBodyBones.LeftHand", "This is the Left Wrist bone." },
{ "HumanBodyBones.LeftIndexDistal", "This is the left index 3rd phalange." },
{ "HumanBodyBones.LeftIndexIntermediate", "This is the left index 2nd phalange." },
{ "HumanBodyBones.LeftIndexProximal", "This is the left index 1st phalange." },
{ "HumanBodyBones.LeftLittleDistal", "This is the left little 3rd phalange." },
{ "HumanBodyBones.LeftLittleIntermediate", "This is the left little 2nd phalange." },
{ "HumanBodyBones.LeftLittleProximal", "This is the left little 1st phalange." },
{ "HumanBodyBones.LeftLowerArm", "This is the Left Elbow bone." },
{ "HumanBodyBones.LeftLowerLeg", "This is the Left Knee bone." },
{ "HumanBodyBones.LeftMiddleDistal", "This is the left middle 3rd phalange." },
{ "HumanBodyBones.LeftMiddleIntermediate", "This is the left middle 2nd phalange." },
{ "HumanBodyBones.LeftMiddleProximal", "This is the left middle 1st phalange." },
{ "HumanBodyBones.LeftRingDistal", "This is the left ring 3rd phalange." },
{ "HumanBodyBones.LeftRingIntermediate", "This is the left ring 2nd phalange." },
{ "HumanBodyBones.LeftRingProximal", "This is the left ring 1st phalange." },
{ "HumanBodyBones.LeftShoulder", "This is the Left Shoulder bone." },
{ "HumanBodyBones.LeftThumbDistal", "This is the left thumb 3rd phalange." },
{ "HumanBodyBones.LeftThumbIntermediate", "This is the left thumb 2nd phalange." },
{ "HumanBodyBones.LeftThumbProximal", "This is the left thumb 1st phalange." },
{ "HumanBodyBones.LeftToes", "This is the Left Toes bone." },
{ "HumanBodyBones.LeftUpperArm", "This is the Left Upper Arm bone." },
{ "HumanBodyBones.LeftUpperLeg", "This is the Left Upper Leg bone." },
{ "HumanBodyBones.Neck", "This is the Neck bone." },
{ "HumanBodyBones.RightEye", "This is the Right Eye bone." },
{ "HumanBodyBones.RightFoot", "This is the Right Ankle bone." },
{ "HumanBodyBones.RightHand", "This is the Right Wrist bone." },
{ "HumanBodyBones.RightIndexDistal", "This is the right index 3rd phalange." },
{ "HumanBodyBones.RightIndexIntermediate", "This is the right index 2nd phalange." },
{ "HumanBodyBones.RightIndexProximal", "This is the right index 1st phalange." },
{ "HumanBodyBones.RightLittleDistal", "This is the right little 3rd phalange." },
{ "HumanBodyBones.RightLittleIntermediate", "This is the right little 2nd phalange." },
{ "HumanBodyBones.RightLittleProximal", "This is the right little 1st phalange." },
{ "HumanBodyBones.RightLowerArm", "This is the Right Elbow bone." },
{ "HumanBodyBones.RightLowerLeg", "This is the Right Knee bone." },
{ "HumanBodyBones.RightMiddleDistal", "This is the right middle 3rd phalange." },
{ "HumanBodyBones.RightMiddleIntermediate", "This is the right middle 2nd phalange." },
{ "HumanBodyBones.RightMiddleProximal", "This is the right middle 1st phalange." },
{ "HumanBodyBones.RightRingDistal", "This is the right ring 3rd phalange." },
{ "HumanBodyBones.RightRingIntermediate", "This is the right ring 2nd phalange." },
{ "HumanBodyBones.RightRingProximal", "This is the right ring 1st phalange." },
{ "HumanBodyBones.RightShoulder", "This is the Right Shoulder bone." },
{ "HumanBodyBones.RightThumbDistal", "This is the right thumb 3rd phalange." },
{ "HumanBodyBones.RightThumbIntermediate", "This is the right thumb 2nd phalange." },
{ "HumanBodyBones.RightThumbProximal", "This is the right thumb 1st phalange." },
{ "HumanBodyBones.RightToes", "This is the Right Toes bone." },
{ "HumanBodyBones.RightUpperArm", "This is the Right Upper Arm bone." },
{ "HumanBodyBones.RightUpperLeg", "This is the Right Upper Leg bone." },
{ "HumanBodyBones.Spine", "This is the first Spine bone." },
{ "HumanBone", "The mapping between a bone in the model and the conceptual bone in the Mecanim human anatomy." },
{ "HumanBone-boneName", "The name of the bone to which the Mecanim human bone is mapped." },
{ "HumanBone-humanName", "The name of the Mecanim human bone to which the bone from the model is mapped." },
{ "HumanBone-limit", "The rotation limits that define the muscle for this bone." },
{ "HumanDescription", "Class that holds humanoid avatar parameters to pass to the AvatarBuilder.BuildHumanAvatar function." },
{ "HumanDescription-armStretch", "Amount by which the arm's length is allowed to stretch when using IK." },
{ "HumanDescription-feetSpacing", "Modification to the minimum distance between the feet of a humanoid model." },
{ "HumanDescription-human", "Mapping between Mecanim bone names and bone names in the rig." },
{ "HumanDescription-legStretch", "Amount by which the leg's length is allowed to stretch when using IK." },
{ "HumanDescription-lowerArmTwist", "Defines how the lower arm's roll/twisting is distributed between the elbow and wrist joints." },
{ "HumanDescription-lowerLegTwist", "Defines how the lower leg's roll/twisting is distributed between the knee and ankle." },
{ "HumanDescription-skeleton", "List of bone Transforms to include in the model." },
{ "HumanDescription-upperArmTwist", "Defines how the lower arm's roll/twisting is distributed between the shoulder and elbow joints." },
{ "HumanDescription-upperLegTwist", "Defines how the upper leg's roll/twisting is distributed between the thigh and knee joints." },
{ "HumanLimit", "This class stores the rotation limits that define the muscle for a single human bone." },
{ "HumanLimit-axisLength", "Length of the bone to which the limit is applied." },
{ "HumanLimit-center", "The default orientation of a bone when no muscle action is applied." },
{ "HumanLimit-max", "The maximum rotation away from the initial value that this muscle can apply." },
{ "HumanLimit-min", "The maximum negative rotation away from the initial value that this muscle can apply." },
{ "HumanLimit-useDefaultValues", "Should this limit use the default values?" },
{ "HumanTrait", "Details of all the human bone and muscle types defined by Mecanim." },
{ "HumanTrait.BoneCount", "The number of human bone types defined by Mecanim." },
{ "HumanTrait.BoneFromMuscle", "Return the bone to which a particular muscle is connected." },
{ "HumanTrait.BoneName", "Array of the names of all human bone types defined by Mecanim." },
{ "HumanTrait.GetMuscleDefaultMax", "Get the default maximum value of rotation for a muscle in degrees." },
{ "HumanTrait.GetMuscleDefaultMin", "Get the default minimum value of rotation for a muscle in degrees." },
{ "HumanTrait.MuscleCount", "The number of human muscle types defined by Mecanim." },
{ "HumanTrait.MuscleFromBone", "Obtain the muscle index for a particular bone index and \"degree of freedom\"." },
{ "HumanTrait.MuscleName", "Array of the names of all human muscle types defined by Mecanim." },
{ "HumanTrait.RequiredBone", "Is the bone a member of the minimal set of bones that Mecanim requires for a human model?" },
{ "HumanTrait.RequiredBoneCount", "The number of bone types that are required by Mecanim for any human model." },
{ "ImageEffectOpaque", "Any Image Effect with this attribute will be rendered after opaque geometry but before transparent geometry." },
{ "ImageEffectTransformsToLDR", "When using HDR rendering it can sometime be desirable to switch to LDR rendering during ImageEffect rendering." },
{ "ImagePosition", "How image and text is placed inside GUIStyle." },
{ "ImagePosition.ImageAbove", "Image is above the text." },
{ "ImagePosition.ImageLeft", "Image is to the left of the text." },
{ "ImagePosition.ImageOnly", "Only the image is displayed." },
{ "ImagePosition.TextOnly", "Only the text is displayed." },
{ "IMECompositionMode", "Controls IME input." },
{ "IMECompositionMode.Auto", "Enable IME input only when a text field is selected (default)." },
{ "IMECompositionMode.Off", "Disable IME input." },
{ "IMECompositionMode.On", "Enable IME input." },
{ "ImportAssetOptions", "Asset importing options." },
{ "ImportAssetOptions.Default", "Default import options." },
{ "ImportAssetOptions.DontDownloadFromCacheServer", "Force a full reimport but don't download the assets from the cache server." },
{ "ImportAssetOptions.ForceSynchronousImport", "Import all assets synchronously." },
{ "ImportAssetOptions.ForceUncompressedImport", "Forces asset import as uncompressed for edition facilities." },
{ "ImportAssetOptions.ForceUpdate", "User initiated asset import." },
{ "ImportAssetOptions.ImportRecursive", "When a folder is imported, import all its contents as well." },
{ "InitializeOnLoadAttribute", "Allow an editor class to be initialized when Unity loads without action from the user." },
{ "Input", "Interface into the Input system." },
{ "Input-acceleration", "Last measured linear acceleration of a device in three-dimensional space. (Read Only)" },
{ "Input-accelerationEventCount", "Number of acceleration measurements which occurred during last frame." },
{ "Input-accelerationEvents", "Returns list of acceleration measurements which occurred during the last frame. (Read Only) (Allocates temporary variables)." },
{ "Input-anyKey", "Is any key or mouse button currently held down? (Read Only)" },
{ "Input-anyKeyDown", "Returns true the first frame the user hits any key or mouse button. (Read Only)" },
{ "Input-compass", "Property for accessing compass (handheld devices only). (Read Only)" },
{ "Input-compensateSensors", "This property controls if input sensors should be compensated for screen orientation." },
{ "Input-compositionCursorPos", "The current text input position used by IMEs to open windows." },
{ "Input-compositionString", "The current IME composition string being typed by the user." },
{ "Input-deviceOrientation", "Device physical orientation as reported by OS. (Read Only)" },
{ "Input-gyro", "Returns default gyroscope." },
{ "Input-imeCompositionMode", "Controls enabling and disabling of IME input composition." },
{ "Input-imeIsSelected", "Does the user have an IME keyboard input source selected?" },
{ "Input-inputString", "Returns the keyboard input entered this frame. (Read Only)" },
{ "Input-location", "Property for accessing device location (handheld devices only). (Read Only)" },
{ "Input-mousePosition", "The current mouse position in pixel coordinates. (Read Only)" },
{ "Input-multiTouchEnabled", "Property indicating whether the system handles multiple touches." },
{ "Input-simulateMouseWithTouches", "Enables/Disables mouse simulation with touches on Windows Store Apps and Windows Phone 8. By default this option is enabled." },
{ "Input-touchCount", "Number of touches. Guaranteed not to change throughout the frame. (Read Only)" },
{ "Input-touches", "Returns list of objects representing status of all touches during last frame. (Read Only) (Allocates temporary variables)." },
{ "Input.GetAccelerationEvent", "Returns specific acceleration measurement which occurred during last frame. (Does not allocate temporary variables)." },
{ "Input.GetAxis", "Returns the value of the virtual axis identified by axisName." },
{ "Input.GetAxisRaw", "Returns the value of the virtual axis identified by axisName with no smoothing filtering applied." },
{ "Input.GetButton", "Returns true while the virtual button identified by buttonName is held down." },
{ "Input.GetButtonDown", "Returns true during the frame the user pressed down the virtual button identified by buttonName." },
{ "Input.GetButtonUp", "Returns true the first frame the user releases the virtual button identified by buttonName." },
{ "Input.GetJoystickNames", "Returns an array of strings describing the connected joysticks." },
{ "Input.GetKey", "Returns true while the user holds down the key identified by name. Think auto fire." },
{ "Input.GetKeyDown", "Returns true during the frame the user starts pressing down the key identified by name." },
{ "Input.GetKeyUp", "Returns true during the frame the user releases the key identified by name." },
{ "Input.GetMouseButton", "Returns whether the given mouse button is held down." },
{ "Input.GetMouseButtonDown", "Returns true during the frame the user pressed the given mouse button." },
{ "Input.GetMouseButtonUp", "Returns true during the frame the user releases the given mouse button." },
{ "Input.GetTouch", "Returns object representing status of a specific touch. (Does not allocate temporary variables)." },
{ "Input.ResetInputAxes", "Resets all input. After ResetInputAxes all axes return to 0 and all buttons return to 0 for one frame." },
{ "InteractiveCloth", "The InteractiveCloth component is used to simulate objects with cloth physics." },
{ "InteractiveCloth-attachmentResponse", "How much force will be applied to attached rigidbodies?" },
{ "InteractiveCloth-attachmentTearFactor", "How far attached rigid bodies need to be stretched, before they will tear off." },
{ "InteractiveCloth-collisionResponse", "How much force will be applied to colliding rigidbodies?" },
{ "InteractiveCloth-density", "The density of the cloth." },
{ "InteractiveCloth-friction", "The friction of the cloth." },
{ "InteractiveCloth-isTeared", "Did the cloth tear? (Read Only)" },
{ "InteractiveCloth-mesh", "The mesh used as base for the cloth object." },
{ "InteractiveCloth-pressure", "The pressure inside the cloth." },
{ "InteractiveCloth-tearFactor", "How far cloth vertices need to be stretched, before the cloth will tear." },
{ "InteractiveCloth.AddForceAtPosition", "Adds force force to all vertices of the cloth mesh which are with radius distance of position." },
{ "InteractiveCloth.AttachToCollider", "Attaches a collider to the cloth object." },
{ "InteractiveCloth.DetachFromCollider", "Detaches a collider from the cloth object." },
{ "iOSActivityIndicatorStyle", "ActivityIndicator Style (iOS Specific)." },
{ "iOSActivityIndicatorStyle.DontShow", "Do not show ActivityIndicator." },
{ "iOSActivityIndicatorStyle.Gray", "The standard gray style of indicator (UIActivityIndicatorViewStyleGray)." },
{ "iOSActivityIndicatorStyle.White", "The standard white style of indicator (UIActivityIndicatorViewStyleWhite)." },
{ "iOSActivityIndicatorStyle.WhiteLarge", "The large white style of indicator (UIActivityIndicatorViewStyleWhiteLarge)." },
{ "iOSSdkVersion", "Supported iOS SDK versions." },
{ "iOSSdkVersion.DeviceSDK", "Device SDK." },
{ "iOSSdkVersion.SimulatorSDK", "Simulator SDK." },
{ "iOSShowActivityIndicatorOnLoading", "Activity Indicator on loading." },
{ "iOSShowActivityIndicatorOnLoading.DontShow", "Don't Show." },
{ "iOSShowActivityIndicatorOnLoading.Gray", "Gray." },
{ "iOSShowActivityIndicatorOnLoading.White", "White." },
{ "iOSShowActivityIndicatorOnLoading.WhiteLarge", "White Large." },
{ "iOSStatusBarStyle", "iOS status bar style." },
{ "iOSStatusBarStyle.BlackOpaque", "Black opaque." },
{ "iOSStatusBarStyle.BlackTranslucent", "Black translucent." },
{ "iOSStatusBarStyle.Default", "Default." },
{ "iOSTargetDevice", "Target iOS device." },
{ "iOSTargetDevice-iPadOnly", "iPad Only." },
{ "iOSTargetDevice-iPhoneAndiPad", "Universal : iPhone/iPod + iPad." },
{ "iOSTargetDevice-iPhoneOnly", "iPhone/iPod Only." },
{ "iOSTargetOSVersion", "Supported iOS deployment versions." },
{ "iOSTargetOSVersion-iOS_4_0", "iOS 4.0." },
{ "iOSTargetOSVersion-iOS_4_1", "iOS 4.1." },
{ "iOSTargetOSVersion-iOS_4_2", "iOS 4.2." },
{ "iOSTargetOSVersion-iOS_4_3", "iOS 4.3." },
{ "iOSTargetOSVersion-iOS_5_0", "iOS 5.0." },
{ "iOSTargetOSVersion-iOS_5_1", "iOS 5.1." },
{ "iOSTargetOSVersion-iOS_6_0", "iOS 6.0." },
{ "iOSTargetOSVersion-iOS_7_0", "iOS 7.0." },
{ "iOSTargetOSVersion.Unknown", "Unknown iOS version, managed by user." },
{ "iOSTargetResolution", "Deployment target iOS device resolution." },
{ "iOSTargetResolution.Native", "Native device resolution." },
{ "iOSTargetResolution.Resolution320p", "320p (iPhone)." },
{ "iOSTargetResolution.Resolution640p", "640p (iPhone Retina Display)." },
{ "iOSTargetResolution.Resolution768p", "768p (iPad)." },
{ "iOSTargetResolution.ResolutionAutoPerformance", "Auto (Best Performane)." },
{ "iOSTargetResolution.ResolutionAutoQuality", "Auto (Best Quality)." },
{ "iPhone", "Interface into iPhone specific functionality." },
{ "iPhone-advertisingIdentifier", "Advertising ID." },
{ "iPhone-generation", "The generation of the device. (Read Only)" },
{ "iPhone-vendorIdentifier", "Vendor ID." },
{ "iPhone.ResetNoBackupFlag", "Reset \"no backup\" file flag: file will be synced with iCloud/iTunes backup and can be deleted by OS in low storage situations." },
{ "iPhone.SetNoBackupFlag", "Set file flag to be excluded from iCloud/iTunes backup." },
{ "iPhoneGeneration", "iPhone device generation." },
{ "iPhoneGeneration-iPad1Gen", "iPad, first generation." },
{ "iPhoneGeneration-iPad2Gen", "iPad, second generation." },
{ "iPhoneGeneration-iPad3Gen", "iPad, third generation." },
{ "iPhoneGeneration-iPad4Gen", "iPad, fourth generation." },
{ "iPhoneGeneration-iPad5Gen", "iPad Air (fifth generation)." },
{ "iPhoneGeneration-iPadMini1Gen", "iPadMini, first generation." },
{ "iPhoneGeneration-iPadMini2Gen", "iPadMini Retina (second generation)." },
{ "iPhoneGeneration-iPadUnknown", "Yet unknown iPad." },
{ "iPhoneGeneration-iPhone", "First generation device." },
{ "iPhoneGeneration-iPhone3G", "Second generation." },
{ "iPhoneGeneration-iPhone3GS", "Third generation." },
{ "iPhoneGeneration-iPhone4", "Fourth generation." },
{ "iPhoneGeneration-iPhone4S", "Fifth generation." },
{ "iPhoneGeneration-iPhone5", "iPhone5." },
{ "iPhoneGeneration-iPhone5C", "iPhone 5C." },
{ "iPhoneGeneration-iPhone5S", "iPhone 5S." },
{ "iPhoneGeneration-iPhoneUnknown", "Yet unknown iPhone." },
{ "iPhoneGeneration-iPodTouch1Gen", "iPod Touch, first generation." },
{ "iPhoneGeneration-iPodTouch2Gen", "iPod Touch, second generation." },
{ "iPhoneGeneration-iPodTouch3Gen", "iPod Touch, third generation." },
{ "iPhoneGeneration-iPodTouch4Gen", "iPod Touch, fourth generation." },
{ "iPhoneGeneration-iPodTouch5Gen", "iPod Touch, fifth generation." },
{ "iPhoneGeneration-iPodTouchUnknown", "Yet unknown iPodTouch." },
{ "ISerializationCallbackReceiver", "Interface to receive callbacks upon serialization and deserialization." },
{ "ISerializationCallbackReceiver.OnAfterDeserialize", "See ISerializationCallbackReceiver.OnBeforeSerialize for documentation on how to use this method." },
{ "ISerializationCallbackReceiver.OnBeforeSerialize", "Implement this method to receive a callback after unity serialized your object." },
{ "Joint", "Joint is the base class for all joints." },
{ "Joint-anchor", "The Position of the anchor around which the joints motion is constrained." },
{ "Joint-autoConfigureConnectedAnchor", "Should the connectedAnchor be calculated automatically?" },
{ "Joint-axis", "The Direction of the axis around which the body is constrained." },
{ "Joint-breakForce", "The force that needs to be applied for this joint to break." },
{ "Joint-breakTorque", "The torque that needs to be applied for this joint to break." },
{ "Joint-connectedAnchor", "Position of the anchor relative to the connected Rigidbody." },
{ "Joint-connectedBody", "A reference to another rigidbody this joint connects to." },
{ "Joint-enableCollision", "Enable collision between bodies connected with the joint." },
{ "Joint.OnJointBreak", "Called when a joint attached to the same game object broke." },
{ "Joint2D", "Parent class for joints to connect Rigidbody2D objects." },
{ "Joint2D-collideConnected", "Can the joint collide with the other Rigidbody2D object to which it is attached?" },
{ "Joint2D-connectedBody", "The Rigidbody2D object to which the other end of the joint is attached (ie, the object without the joint component)." },
{ "JointAngleLimits2D", "Angular limits on the rotation of a Rigidbody2D object around a HingeJoint2D." },
{ "JointAngleLimits2D-max", "Upper angular limit of rotation." },
{ "JointAngleLimits2D-min", "Lower angular limit of rotation." },
{ "JointDrive", "How the joint's movement will behave along its local X axis." },
{ "JointDrive-maximumForce", "Amount of force applied to push the object toward the defined direction." },
{ "JointDrive-mode", "Whether the drive should attempt to reach position, velocity, both or nothing." },
{ "JointDrive-positionDamper", "Resistance strength against the Position Spring. Only used if mode includes Position." },
{ "JointDrive-positionSpring", "Strength of a rubber-band pull toward the defined direction. Only used if mode includes Position." },
{ "JointDriveMode", "The ConfigurableJoint attempts to attain position / velocity targets based on this flag." },
{ "JointDriveMode.None", "Don't apply any forces to reach the target." },
{ "JointDriveMode.Position", "Try to reach the specified target position." },
{ "JointDriveMode.PositionAndVelocity", "Try to reach the specified target position and velocity." },
{ "JointDriveMode.Velocity", "Try to reach the specified target velocity." },
{ "JointLimits", "JointLimits is used by the HingeJoint to limit the joints angle." },
{ "JointLimits-max", "The upper limit of the joint." },
{ "JointLimits-maxBounce", "The bounciness of the joint when hitting the upper limit of the joint." },
{ "JointLimits-min", "The lower limit of the joint." },
{ "JointLimits-minBounce", "The bounciness of the joint when hitting the lower limit of the joint." },
{ "JointLimitState2D", "Represents the state of a joint limit." },
{ "JointLimitState2D.EqualLimits", "Represents a state where the joint limit is at the specified lower and upper limits (they are identical)." },
{ "JointLimitState2D.Inactive", "Represents a state where the joint limit is inactive." },
{ "JointLimitState2D.LowerLimit", "Represents a state where the joint limit is at the specified lower limit." },
{ "JointLimitState2D.UpperLimit", "Represents a state where the joint limit is at the specified upper limit." },
{ "JointMotor", "The JointMotor is used to motorize a joint." },
{ "JointMotor-force", "The motor will apply a force." },
{ "JointMotor-freeSpin", "If freeSpin is enabled the motor will only accelerate but never slow down." },
{ "JointMotor-targetVelocity", "The motor will apply a force up to force to achieve targetVelocity." },
{ "JointMotor2D", "Parameters for the optional motor force applied to a Joint2D." },
{ "JointMotor2D-maxMotorTorque", "The maximum force that can be applied to the Rigidbody2D at the joint to attain the target speed." },
{ "JointMotor2D-motorSpeed", "The desired speed for the Rigidbody2D to reach as it moves with the joint." },
{ "JointProjectionMode", "Determines how to snap physics joints back to its constrained position when it drifts off too much." },
{ "JointProjectionMode.None", "Don't snap at all." },
{ "JointProjectionMode.PositionAndRotation", "Snap both position and rotation." },
{ "JointProjectionMode.PositionOnly", "Snap Position only." },
{ "JointSpring", "JointSpring is used add a spring force to HingeJoint and PhysicMaterial." },
{ "JointSpring-damper", "The damper force uses to dampen the spring." },
{ "JointSpring-spring", "The spring forces used to reach the target position." },
{ "JointSpring-targetPosition", "The target position the joint attempts to reach." },
{ "JointSuspension2D", "Joint suspension is used to define how suspension works on a WheelJoint2D." },
{ "JointSuspension2D-angle", "The world angle along which the suspension will move. This provides 2D constrained motion similar to a SliderJoint2D. This is typically how suspension works in the real world." },
{ "JointSuspension2D-dampingRatio", "The amount by which the suspension spring force is reduced in proportion to the movement speed." },
{ "JointSuspension2D-frequency", "The frequency at which the suspension spring oscillates." },
{ "JointTranslationLimits2D", "Motion limits of a Rigidbody2D object along a SliderJoint2D." },
{ "JointTranslationLimits2D-max", "Maximum distance the Rigidbody2D object can move from the Slider Joint's anchor." },
{ "JointTranslationLimits2D-min", "Minimum distance the Rigidbody2D object can move from the Slider Joint's anchor." },
{ "KeyCode", "Key codes returned by Event.keyCode. These map directly to a physical key on the keyboard." },
{ "KeyCode.A", "'a' key." },
{ "KeyCode.Alpha0", "The '0' key on the top of the alphanumeric keyboard." },
{ "KeyCode.Alpha1", "The '1' key on the top of the alphanumeric keyboard." },
{ "KeyCode.Alpha2", "The '2' key on the top of the alphanumeric keyboard." },
{ "KeyCode.Alpha3", "The '3' key on the top of the alphanumeric keyboard." },
{ "KeyCode.Alpha4", "The '4' key on the top of the alphanumeric keyboard." },
{ "KeyCode.Alpha5", "The '5' key on the top of the alphanumeric keyboard." },
{ "KeyCode.Alpha6", "The '6' key on the top of the alphanumeric keyboard." },
{ "KeyCode.Alpha7", "The '7' key on the top of the alphanumeric keyboard." },
{ "KeyCode.Alpha8", "The '8' key on the top of the alphanumeric keyboard." },
{ "KeyCode.Alpha9", "The '9' key on the top of the alphanumeric keyboard." },
{ "KeyCode.AltGr", "Alt Gr key." },
{ "KeyCode.Ampersand", "Ampersand key '&'." },
{ "KeyCode.Asterisk", "Asterisk key '*'." },
{ "KeyCode.At", "At key '@'." },
{ "KeyCode.B", "'b' key." },
{ "KeyCode.BackQuote", "Back quote key '`'." },
{ "KeyCode.Backslash", "Backslash key '\'." },
{ "KeyCode.Backspace", "The backspace key." },
{ "KeyCode.Break", "Break key." },
{ "KeyCode.C", "'c' key." },
{ "KeyCode.CapsLock", "Capslock key." },
{ "KeyCode.Caret", "Caret key '^'." },
{ "KeyCode.Clear", "The Clear key." },
{ "KeyCode.Colon", "Colon ':' key." },
{ "KeyCode.Comma", "Comma ',' key." },
{ "KeyCode.D", "'d' key." },
{ "KeyCode.Delete", "The forward delete key." },
{ "KeyCode.Dollar", "Dollar sign key '$'." },
{ "KeyCode.DoubleQuote", "Double quote key '\"'." },
{ "KeyCode.DownArrow", "Down arrow key." },
{ "KeyCode.E", "'e' key." },
{ "KeyCode.End", "End key." },
{ "KeyCode.Equals", "Equals '=' key." },
{ "KeyCode.Escape", "Escape key." },
{ "KeyCode.Exclaim", "Exclamation mark key '!'." },
{ "KeyCode.F", "'f' key." },
{ "KeyCode.F1", "F1 function key." },
{ "KeyCode.F10", "F10 function key." },
{ "KeyCode.F11", "F11 function key." },
{ "KeyCode.F12", "F12 function key." },
{ "KeyCode.F13", "F13 function key." },
{ "KeyCode.F14", "F14 function key." },
{ "KeyCode.F15", "F15 function key." },
{ "KeyCode.F2", "F2 function key." },
{ "KeyCode.F3", "F3 function key." },
{ "KeyCode.F4", "F4 function key." },
{ "KeyCode.F5", "F5 function key." },
{ "KeyCode.F6", "F6 function key." },
{ "KeyCode.F7", "F7 function key." },
{ "KeyCode.F8", "F8 function key." },
{ "KeyCode.F9", "F9 function key." },
{ "KeyCode.G", "'g' key." },
{ "KeyCode.Greater", "Greater than '>' key." },
{ "KeyCode.H", "'h' key." },
{ "KeyCode.Hash", "Hash key '#'." },
{ "KeyCode.Help", "Help key." },
{ "KeyCode.Home", "Home key." },
{ "KeyCode.I", "'i' key." },
{ "KeyCode.Insert", "Insert key key." },
{ "KeyCode.J", "'j' key." },
{ "KeyCode.Joystick1Button0", "Button 0 on first joystick." },
{ "KeyCode.Joystick1Button1", "Button 1 on first joystick." },
{ "KeyCode.Joystick1Button10", "Button 10 on first joystick." },
{ "KeyCode.Joystick1Button11", "Button 11 on first joystick." },
{ "KeyCode.Joystick1Button12", "Button 12 on first joystick." },
{ "KeyCode.Joystick1Button13", "Button 13 on first joystick." },
{ "KeyCode.Joystick1Button14", "Button 14 on first joystick." },
{ "KeyCode.Joystick1Button15", "Button 15 on first joystick." },
{ "KeyCode.Joystick1Button16", "Button 16 on first joystick." },
{ "KeyCode.Joystick1Button17", "Button 17 on first joystick." },
{ "KeyCode.Joystick1Button18", "Button 18 on first joystick." },
{ "KeyCode.Joystick1Button19", "Button 19 on first joystick." },
{ "KeyCode.Joystick1Button2", "Button 2 on first joystick." },
{ "KeyCode.Joystick1Button3", "Button 3 on first joystick." },
{ "KeyCode.Joystick1Button4", "Button 4 on first joystick." },
{ "KeyCode.Joystick1Button5", "Button 5 on first joystick." },
{ "KeyCode.Joystick1Button6", "Button 6 on first joystick." },
{ "KeyCode.Joystick1Button7", "Button 7 on first joystick." },
{ "KeyCode.Joystick1Button8", "Button 8 on first joystick." },
{ "KeyCode.Joystick1Button9", "Button 9 on first joystick." },
{ "KeyCode.Joystick2Button0", "Button 0 on second joystick." },
{ "KeyCode.Joystick2Button1", "Button 1 on second joystick." },
{ "KeyCode.Joystick2Button10", "Button 10 on second joystick." },
{ "KeyCode.Joystick2Button11", "Button 11 on second joystick." },
{ "KeyCode.Joystick2Button12", "Button 12 on second joystick." },
{ "KeyCode.Joystick2Button13", "Button 13 on second joystick." },
{ "KeyCode.Joystick2Button14", "Button 14 on second joystick." },
{ "KeyCode.Joystick2Button15", "Button 15 on second joystick." },
{ "KeyCode.Joystick2Button16", "Button 16 on second joystick." },
{ "KeyCode.Joystick2Button17", "Button 17 on second joystick." },
{ "KeyCode.Joystick2Button18", "Button 18 on second joystick." },
{ "KeyCode.Joystick2Button19", "Button 19 on second joystick." },
{ "KeyCode.Joystick2Button2", "Button 2 on second joystick." },
{ "KeyCode.Joystick2Button3", "Button 3 on second joystick." },
{ "KeyCode.Joystick2Button4", "Button 4 on second joystick." },
{ "KeyCode.Joystick2Button5", "Button 5 on second joystick." },
{ "KeyCode.Joystick2Button6", "Button 6 on second joystick." },
{ "KeyCode.Joystick2Button7", "Button 7 on second joystick." },
{ "KeyCode.Joystick2Button8", "Button 8 on second joystick." },
{ "KeyCode.Joystick2Button9", "Button 9 on second joystick." },
{ "KeyCode.Joystick3Button0", "Button 0 on third joystick." },
{ "KeyCode.Joystick3Button1", "Button 1 on third joystick." },
{ "KeyCode.Joystick3Button10", "Button 10 on third joystick." },
{ "KeyCode.Joystick3Button11", "Button 11 on third joystick." },
{ "KeyCode.Joystick3Button12", "Button 12 on third joystick." },
{ "KeyCode.Joystick3Button13", "Button 13 on third joystick." },
{ "KeyCode.Joystick3Button14", "Button 14 on third joystick." },
{ "KeyCode.Joystick3Button15", "Button 15 on third joystick." },
{ "KeyCode.Joystick3Button16", "Button 16 on third joystick." },
{ "KeyCode.Joystick3Button17", "Button 17 on third joystick." },
{ "KeyCode.Joystick3Button18", "Button 18 on third joystick." },
{ "KeyCode.Joystick3Button19", "Button 19 on third joystick." },
{ "KeyCode.Joystick3Button2", "Button 2 on third joystick." },
{ "KeyCode.Joystick3Button3", "Button 3 on third joystick." },
{ "KeyCode.Joystick3Button4", "Button 4 on third joystick." },
{ "KeyCode.Joystick3Button5", "Button 5 on third joystick." },
{ "KeyCode.Joystick3Button6", "Button 6 on third joystick." },
{ "KeyCode.Joystick3Button7", "Button 7 on third joystick." },
{ "KeyCode.Joystick3Button8", "Button 8 on third joystick." },
{ "KeyCode.Joystick3Button9", "Button 9 on third joystick." },
{ "KeyCode.Joystick4Button0", "Button 0 on forth joystick." },
{ "KeyCode.Joystick4Button1", "Button 1 on forth joystick." },
{ "KeyCode.Joystick4Button10", "Button 10 on forth joystick." },
{ "KeyCode.Joystick4Button11", "Button 11 on forth joystick." },
{ "KeyCode.Joystick4Button12", "Button 12 on forth joystick." },
{ "KeyCode.Joystick4Button13", "Button 13 on forth joystick." },
{ "KeyCode.Joystick4Button14", "Button 14 on forth joystick." },
{ "KeyCode.Joystick4Button15", "Button 15 on forth joystick." },
{ "KeyCode.Joystick4Button16", "Button 16 on forth joystick." },
{ "KeyCode.Joystick4Button17", "Button 17 on forth joystick." },
{ "KeyCode.Joystick4Button18", "Button 18 on forth joystick." },
{ "KeyCode.Joystick4Button19", "Button 19 on forth joystick." },
{ "KeyCode.Joystick4Button2", "Button 2 on forth joystick." },
{ "KeyCode.Joystick4Button3", "Button 3 on forth joystick." },
{ "KeyCode.Joystick4Button4", "Button 4 on forth joystick." },
{ "KeyCode.Joystick4Button5", "Button 5 on forth joystick." },
{ "KeyCode.Joystick4Button6", "Button 6 on forth joystick." },
{ "KeyCode.Joystick4Button7", "Button 7 on forth joystick." },
{ "KeyCode.Joystick4Button8", "Button 8 on forth joystick." },
{ "KeyCode.Joystick4Button9", "Button 9 on forth joystick." },
{ "KeyCode.JoystickButton0", "Button 0 on any joystick." },
{ "KeyCode.JoystickButton1", "Button 1 on any joystick." },
{ "KeyCode.JoystickButton10", "Button 10 on any joystick." },
{ "KeyCode.JoystickButton11", "Button 11 on any joystick." },
{ "KeyCode.JoystickButton12", "Button 12 on any joystick." },
{ "KeyCode.JoystickButton13", "Button 13 on any joystick." },
{ "KeyCode.JoystickButton14", "Button 14 on any joystick." },
{ "KeyCode.JoystickButton15", "Button 15 on any joystick." },
{ "KeyCode.JoystickButton16", "Button 16 on any joystick." },
{ "KeyCode.JoystickButton17", "Button 17 on any joystick." },
{ "KeyCode.JoystickButton18", "Button 18 on any joystick." },
{ "KeyCode.JoystickButton19", "Button 19 on any joystick." },
{ "KeyCode.JoystickButton2", "Button 2 on any joystick." },
{ "KeyCode.JoystickButton3", "Button 3 on any joystick." },
{ "KeyCode.JoystickButton4", "Button 4 on any joystick." },
{ "KeyCode.JoystickButton5", "Button 5 on any joystick." },
{ "KeyCode.JoystickButton6", "Button 6 on any joystick." },
{ "KeyCode.JoystickButton7", "Button 7 on any joystick." },
{ "KeyCode.JoystickButton8", "Button 8 on any joystick." },
{ "KeyCode.JoystickButton9", "Button 9 on any joystick." },
{ "KeyCode.K", "'k' key." },
{ "KeyCode.Keypad0", "Numeric keypad 0." },
{ "KeyCode.Keypad1", "Numeric keypad 1." },
{ "KeyCode.Keypad2", "Numeric keypad 2." },
{ "KeyCode.Keypad3", "Numeric keypad 3." },
{ "KeyCode.Keypad4", "Numeric keypad 4." },
{ "KeyCode.Keypad5", "Numeric keypad 5." },
{ "KeyCode.Keypad6", "Numeric keypad 6." },
{ "KeyCode.Keypad7", "Numeric keypad 7." },
{ "KeyCode.Keypad8", "Numeric keypad 8." },
{ "KeyCode.Keypad9", "Numeric keypad 9." },
{ "KeyCode.KeypadDivide", "Numeric keypad '/'." },
{ "KeyCode.KeypadEnter", "Numeric keypad enter." },
{ "KeyCode.KeypadEquals", "Numeric keypad '='." },
{ "KeyCode.KeypadMinus", "Numeric keypad '-'." },
{ "KeyCode.KeypadMultiply", "Numeric keypad '*'." },
{ "KeyCode.KeypadPeriod", "Numeric keypad '.'." },
{ "KeyCode.KeypadPlus", "Numeric keypad '+'." },
{ "KeyCode.L", "'l' key." },
{ "KeyCode.LeftAlt", "Left Alt key." },
{ "KeyCode.LeftApple", "Left Command key." },
{ "KeyCode.LeftArrow", "Left arrow key." },
{ "KeyCode.LeftBracket", "Left square bracket key '['." },
{ "KeyCode.LeftCommand", "Left Command key." },
{ "KeyCode.LeftControl", "Left Control key." },
{ "KeyCode.LeftParen", "Left Parenthesis key '('." },
{ "KeyCode.LeftShift", "Left shift key." },
{ "KeyCode.LeftWindows", "Left Windows key." },
{ "KeyCode.Less", "Less than '<' key." },
{ "KeyCode.M", "'m' key." },
{ "KeyCode.Menu", "Menu key." },
{ "KeyCode.Minus", "Minus '-' key." },
{ "KeyCode.Mouse0", "First (primary) mouse button." },
{ "KeyCode.Mouse1", "Second (secondary) mouse button." },
{ "KeyCode.Mouse2", "Third mouse button." },
{ "KeyCode.Mouse3", "Fourth mouse button." },
{ "KeyCode.Mouse4", "Fifth mouse button." },
{ "KeyCode.Mouse5", "Sixth mouse button." },
{ "KeyCode.Mouse6", "Seventh mouse button." },
{ "KeyCode.N", "'n' key." },
{ "KeyCode.None", "Not assigned (never returned as the result of a keystroke)." },
{ "KeyCode.Numlock", "Numlock key." },
{ "KeyCode.O", "'o' key." },
{ "KeyCode.P", "'p' key." },
{ "KeyCode.PageDown", "Page down." },
{ "KeyCode.PageUp", "Page up." },
{ "KeyCode.Pause", "Pause on PC machines." },
{ "KeyCode.Period", "Period '.' key." },
{ "KeyCode.Plus", "Plus key '+'." },
{ "KeyCode.Print", "Print key." },
{ "KeyCode.Q", "'q' key." },
{ "KeyCode.Question", "Question mark '?' key." },
{ "KeyCode.Quote", "Quote key '." },
{ "KeyCode.R", "'r' key." },
{ "KeyCode.Return", "Return key." },
{ "KeyCode.RightAlt", "Right Alt key." },
{ "KeyCode.RightApple", "Right Command key." },
{ "KeyCode.RightArrow", "Right arrow key." },
{ "KeyCode.RightBracket", "Right square bracket key ']'." },
{ "KeyCode.RightCommand", "Right Command key." },
{ "KeyCode.RightControl", "Right Control key." },
{ "KeyCode.RightParen", "Right Parenthesis key ')'." },
{ "KeyCode.RightShift", "Right shift key." },
{ "KeyCode.RightWindows", "Right Windows key." },
{ "KeyCode.S", "'s' key." },
{ "KeyCode.ScrollLock", "Scroll lock key." },
{ "KeyCode.Semicolon", "Semicolon ';' key." },
{ "KeyCode.Slash", "Slash '/' key." },
{ "KeyCode.Space", "Space key." },
{ "KeyCode.SysReq", "Sys Req key." },
{ "KeyCode.T", "'t' key." },
{ "KeyCode.Tab", "The tab key." },
{ "KeyCode.U", "'u' key." },
{ "KeyCode.Underscore", "Underscore '_' key." },
{ "KeyCode.UpArrow", "Up arrow key." },
{ "KeyCode.V", "'v' key." },
{ "KeyCode.W", "'w' key." },
{ "KeyCode.X", "'x' key." },
{ "KeyCode.Y", "'y' key." },
{ "KeyCode.Z", "'z' key." },
{ "Keyframe", "A single keyframe that can be injected into an animation curve." },
{ "Keyframe-ctor", "Create a keyframe." },
{ "Keyframe-inTangent", "Describes the tangent when approaching this point from the previous point in the curve." },
{ "Keyframe-outTangent", "Describes the tangent when leaving this point towards the next point in the curve." },
{ "Keyframe-time", "The time of the keyframe." },
{ "Keyframe-value", "The value of the curve at keyframe." },
{ "LayerMask", "LayerMask allow you to display the LayerMask popup menu in the inspector." },
{ "LayerMask-operator_int", "Implicitly converts an integer to a LayerMask." },
{ "LayerMask-value", "Converts a layer mask value to an integer value." },
{ "LayerMask.GetMask", "Given a set of layer names as defined by either a Builtin or a User Layer in the Tag Manager, returns the equivalent layer mask for all of them." },
{ "LayerMask.LayerToName", "Given a layer number, returns the name of the layer as defined in either a Builtin or a User Layer in the Tag Manager." },
{ "LayerMask.NameToLayer", "Given a layer name, returns the layer index as defined by either a Builtin or a User Layer in the Tag Manager." },
{ "LensFlare", "Script interface for a Lens flare component." },
{ "LensFlare-brightness", "The strength of the flare." },
{ "LensFlare-color", "The color of the flare." },
{ "LensFlare-fadeSpeed", "The fade speed of the flare." },
{ "LensFlare-flare", "The flare asset to use." },
{ "Light", "Script interface for light components." },
{ "Light-alreadyLightmapped", "Has the light already been lightmapped." },
{ "Light-areaSize", "The size of the area light. Editor only." },
{ "Light-color", "The color of the light." },
{ "Light-cookie", "The cookie texture projected by the light." },
{ "Light-cookieSize", "The size of a directional light's cookie." },
{ "Light-cullingMask", "This is used to light certain objects in the scene selectively." },
{ "Light-flare", "The flare asset to use for this light." },
{ "Light-intensity", "The Intensity of a light is multiplied with the Light color." },
{ "Light-range", "The range of the light." },
{ "Light-renderMode", "How to render the light." },
{ "Light-shadowBias", "Shadow mapping bias." },
{ "Light-shadows", "How this light casts shadows" },
{ "Light-shadowSoftness", "Softness of directional light's soft shadows." },
{ "Light-shadowSoftnessFade", "Fadeout speed of directional light's soft shadows." },
{ "Light-shadowStrength", "Strength of light's shadows." },
{ "Light-spotAngle", "The angle of the light's spotlight cone in degrees." },
{ "Light-type", "The type of the light." },
{ "LightmapBakeQuality", "Bake quality setting for LightmapEditorSettings." },
{ "LightmapBakeQuality.High", "High quality bake for final renderings." },
{ "LightmapBakeQuality.Low", "Low quality bake for preview renderings." },
{ "LightmapData", "Data of a lightmap." },
{ "LightmapData-lightmapFar", "Lightmap storing the full incoming light." },
{ "LightmapData-lightmapNear", "Lightmap storing only the indirect incoming light." },
{ "LightmapEditorSettings", "Various settings for the bake." },
{ "LightmapEditorSettings-aoAmount", "Controls how much Ambient Occlusion to blend into the Final Gather solution." },
{ "LightmapEditorSettings-aoContrast", "Controls the look of the transition from black to white." },
{ "LightmapEditorSettings-aoMaxDistance", "Beyond this distance a ray is considered to be unoccluded." },
{ "LightmapEditorSettings-bounceBoost", "Boosts indirect light (Beast's diffuseBoost property, pow(colorComponent, (1.0 / diffuseBoost)))." },
{ "LightmapEditorSettings-bounceIntensity", "Indirect light intensity multiplier." },
{ "LightmapEditorSettings-bounces", "Number of light bounces in the global illumination computation (with 0 meaning direct light only)." },
{ "LightmapEditorSettings-finalGatherContrastThreshold", "Contrast threshold between neighbouring surface points." },
{ "LightmapEditorSettings-finalGatherGradientThreshold", "Controls how the irradiance gradient is used in the interpolation." },
{ "LightmapEditorSettings-finalGatherInterpolationPoints", "The number of final gather points to interpolate between." },
{ "LightmapEditorSettings-finalGatherRays", "Number of rays used in the final gather integrator." },
{ "LightmapEditorSettings-lastUsedResolution", "Last used lightmap resolution (i.e. resolution of the lightmaps currently in the scene) in texels per world unit." },
{ "LightmapEditorSettings-lockAtlas", "If enabled, Beast atlasing won't be run and lightmap indices, tiling and offset won't be modified on Mesh Renderers." },
{ "LightmapEditorSettings-maxAtlasHeight", "The maximum height of an individual lightmap texture." },
{ "LightmapEditorSettings-maxAtlasWidth", "The maximum width of an individual lightmap texture." },
{ "LightmapEditorSettings-padding", "Texel separation between shapes." },
{ "LightmapEditorSettings-quality", "Quality of the bake." },
{ "LightmapEditorSettings-resolution", "Lightmap resolution in texels per world unit." },
{ "LightmapEditorSettings-skyLightColor", "Sky light color." },
{ "LightmapEditorSettings-skyLightIntensity", "Sky light intensity." },
{ "LightmapEditorSettings-textureCompression", "Whether to use DXT1 compression on the generated lightmaps." },
{ "Lightmapping", "Allows to control the lightmapping job." },
{ "Lightmapping-isRunning", "Returns true when the bake job is running, false otherwise (Read Only)." },
{ "Lightmapping.Bake", "Stars a synchronous bake job." },
{ "Lightmapping.BakeAsync", "Starts an asynchronous bake job." },
{ "Lightmapping.BakeLightProbesOnly", "Starts a synchronous bake job, but only bakes light probes." },
{ "Lightmapping.BakeLightProbesOnlyAsync", "Starts an asynchronous bake job, but only bakes light probes." },
{ "Lightmapping.BakeSelected", "Stars a synchronous bake job for the selected objects." },
{ "Lightmapping.BakeSelectedAsync", "Starts an asynchronous bake job for the selected objects." },
{ "Lightmapping.Cancel", "Cancels the currently running asynchronous bake job." },
{ "Lightmapping.Clear", "Deletes all lightmap assets and makes all lights behave as if they weren't baked yet." },
{ "Lightmapping.Tetrahedralize", "Calculates a Delaunay Tetrahedralization of the 'positions' point set - the same way the lightmapper." },
{ "LightmapSettings", "Stores lightmaps of the scene." },
{ "LightmapSettings-bakedColorSpace", "Color space of the lightmap." },
{ "LightmapSettings-lightmaps", "Lightmap array." },
{ "LightmapSettings-lightmapsMode", "Single, Dual or Directional lightmaps rendering mode." },
{ "LightmapSettings-lightProbes", "Holds all data needed by the light probes." },
{ "LightmapsMode", "Single, dual, or directional lightmaps rendering mode." },
{ "LightmapsMode.Directional", "Directional rendering mode." },
{ "LightmapsMode.Dual", "Dual lightmap rendering mode." },
{ "LightmapsMode.Single", "Single, traditional lightmap rendering mode." },
{ "LightProbeGroup", "Light Probe Group." },
{ "LightProbeGroup-probePositions", "Editor only function to access and modify probe positions." },
{ "LightProbes", "Stores light probes for the scene." },
{ "LightProbes-cellCount", "The number of cells (tetrahedra + outer cells) the space is divided to." },
{ "LightProbes-coefficients", "Coefficients of the baked light probes. The coefficients represent a 3-band RGB spherical harmonics probe, with a total of 27 floats per light probe, laid out: rgbrgbrgb..." },
{ "LightProbes-count", "The number of light probes." },
{ "LightProbes-positions", "Positions of the baked light probes." },
{ "LightProbes.GetInterpolatedLightProbe", "Returns spherical harmonics coefficients of a light probe at the given position. The light probe is interpolated from the light probes baked." },
{ "LightRenderMode", "How the Light is rendered." },
{ "LightRenderMode.Auto", "Automatically choose the render mode." },
{ "LightRenderMode.ForcePixel", "Force the Light to be a pixel light." },
{ "LightRenderMode.ForceVertex", "Force the Light to be a vertex light." },
{ "LightShadows", "Shadow casting options for a Light." },
{ "LightShadows.Hard", "Cast \"hard\" shadows (with no shadow filtering)." },
{ "LightShadows.None", "Do not cast shadows (default)." },
{ "LightShadows.Soft", "Cast \"soft\" shadows (with 4x PCF filtering)." },
{ "LightType", "The type of a Light." },
{ "LightType.Area", "The light is an area light. It affects only lightmaps and lightprobes." },
{ "LightType.Directional", "The light is a directional light." },
{ "LightType.Point", "The light is a point light." },
{ "LightType.Spot", "The light is a spot light." },
{ "LineRenderer", "The line renderer is used to draw free-floating lines in 3D space." },
{ "LineRenderer-useWorldSpace", "If enabled, the lines are defined in world space." },
{ "LineRenderer.SetColors", "Set the line color at the start and at the end." },
{ "LineRenderer.SetPosition", "Set the position of the vertex in the line." },
{ "LineRenderer.SetVertexCount", "Set the number of line segments." },
{ "LineRenderer.SetWidth", "Set the line width at the start and at the end." },
{ "LocalNotification", "LocalNotification is a wrapper around the UILocalNotification class found in the Apple UIKit framework and is only available on iPhone/iPad/iPod Touch." },
{ "LocalNotification-alertAction", "The title of the action button or slider." },
{ "LocalNotification-alertBody", "The message displayed in the notification alert." },
{ "LocalNotification-alertLaunchImage", "Identifies the image used as the launch image when the user taps the action button." },
{ "LocalNotification-applicationIconBadgeNumber", "The number to display as the application's icon badge." },
{ "LocalNotification-ctor", "Creates a new local notification." },
{ "LocalNotification-defaultSoundName", "The default system sound. (Read Only)" },
{ "LocalNotification-fireDate", "The date and time when the system should deliver the notification." },
{ "LocalNotification-hasAction", "A boolean value that controls whether the alert action is visible or not." },
{ "LocalNotification-repeatCalendar", "The calendar type (Gregorian, Chinese, etc) to use for rescheduling the notification." },
{ "LocalNotification-repeatInterval", "The calendar interval at which to reschedule the notification." },
{ "LocalNotification-soundName", "The name of the sound file to play when an alert is displayed." },
{ "LocalNotification-timeZone", "The time zone of the notification's fire date." },
{ "LocalNotification-userInfo", "A dictionary for passing custom information to the notified application." },
{ "LocationInfo", "Structure describing device location." },
{ "LocationInfo-altitude", "Geographical device location altitude." },
{ "LocationInfo-horizontalAccuracy", "Horizontal accuracy of the location." },
{ "LocationInfo-latitude", "Geographical device location latitude." },
{ "LocationInfo-longitude", "Geographical device location latitude." },
{ "LocationInfo-timestamp", "Timestamp (in seconds since 1970) when location was last time updated." },
{ "LocationInfo-verticalAccuracy", "Vertical accuracy of the location." },
{ "LocationService", "Interface into location functionality." },
{ "LocationService-isEnabledByUser", "Specifies whether location service is enabled in user settings." },
{ "LocationService-lastData", "Last measured device geographical location." },
{ "LocationService-status", "Returns location service status." },
{ "LocationService.Start", "Starts location service updates. Last location coordinates could be." },
{ "LocationService.Stop", "Stops location service updates. This could be useful for saving battery life." },
{ "LocationServiceStatus", "Describes location service status." },
{ "LocationServiceStatus.Failed", "Location service failed (user denied access to location service)." },
{ "LocationServiceStatus.Initializing", "Location service is initializing, some time later it will switch to." },
{ "LocationServiceStatus.Running", "Location service is running and locations could be queried." },
{ "LocationServiceStatus.Stopped", "Location service is stopped." },
{ "LOD", "Structure for building a LOD for passing to the SetLODs function." },
{ "LOD-ctor", "Construct a LOD." },
{ "LOD-renderers", "List of renderers for this LOD level." },
{ "LOD-screenRelativeTransitionHeight", "The screen relative height to use for the transition [0-1]." },
{ "LODGroup", "LODGroup lets you group multiple Renderers into LOD levels." },
{ "LODGroup-enabled", "Enable / Disable the LODGroup - Disabling will turn off all renderers." },
{ "LODGroup-localReferencePoint", "The local reference point against which the LOD distance is calculated." },
{ "LODGroup-lodCount", "The number of LOD levels." },
{ "LODGroup-size", "The size of the LOD object in local space." },
{ "LODGroup.ForceLOD", "" },
{ "LODGroup.RecalculateBounds", "Recalculate the bounding region for the LODGroup (Relatively slow, do not call often)." },
{ "LODGroup.SetLODS", "Set the LODs for the LOD group. This will remove any existing LODs configured on the LODGroup." },
{ "LODUtility", "LOD Utility Helpers." },
{ "LODUtility.CalculateLODGroupBoundingBox", "Recalculate the bounding region for the given LODGroup." },
{ "LogType", "The type of the log message in the delegate registered with Application.RegisterLogCallback." },
{ "LogType.Assert", "LogType used for Asserts. (These indicate an error inside Unity itself.)" },
{ "LogType.Error", "LogType used for Errors." },
{ "LogType.Exception", "LogType used for Exceptions." },
{ "LogType.Log", "LogType used for regular log messages." },
{ "LogType.Warning", "LogType used for Warnings." },
{ "MacFullscreenMode", "Mac fullscreen mode." },
{ "MacFullscreenMode.CaptureDisplay", "Capture the display." },
{ "MacFullscreenMode.FullscreenWindow", "Fullscreen window." },
{ "MacFullscreenMode.FullscreenWindowWithDockAndMenuBar", "Fullscreen window with Dock and Menu bar." },
{ "MasterServer", "The Master Server is used to make matchmaking between servers and clients easy." },
{ "MasterServer-dedicatedServer", "Report this machine as a dedicated server." },
{ "MasterServer-ipAddress", "The IP address of the master server." },
{ "MasterServer-port", "The connection port of the master server." },
{ "MasterServer-updateRate", "Set the minimum update rate for master server host information update." },
{ "MasterServer.ClearHostList", "Clear the host list which was received by MasterServer.PollHostList." },
{ "MasterServer.OnFailedToConnectToMasterServer", "Called on clients or servers when there is a problem connecting to the master server." },
{ "MasterServer.OnMasterServerEvent", "Called on clients or servers when reporting events from the MasterServer." },
{ "MasterServer.PollHostList", "Check for the latest host list received by using MasterServer.RequestHostList." },
{ "MasterServer.RegisterHost", "Register this server on the master server." },
{ "MasterServer.RequestHostList", "Request a host list from the master server." },
{ "MasterServer.UnregisterHost", "Unregister this server from the master server." },
{ "MasterServerEvent", "Describes status messages from the master server as returned in OnMasterServerEvent." },
{ "MasterServerEvent.HostListReceived", "Received a host list from the master server." },
{ "MasterServerEvent.RegistrationFailedGameName", "Registration failed because an empty game name was given." },
{ "MasterServerEvent.RegistrationFailedGameType", "Registration failed because an empty game type was given." },
{ "MasterServerEvent.RegistrationFailedNoServer", "Registration failed because no server is running." },
{ "MasterServerEvent.RegistrationSucceeded", "Registration to master server succeeded, received confirmation." },
{ "MatchTargetWeightMask", "To specify position and rotation weight mask for Animator::MatchTarget." },
{ "MatchTargetWeightMask-ctor", "MatchTargetWeightMask contructor." },
{ "MatchTargetWeightMask-positionXYZWeight", "Position XYZ weight." },
{ "MatchTargetWeightMask-rotationWeight", "Rotation weight." },
{ "Material", "The material class." },
{ "Material-color", "The main material's color." },
{ "Material-ctor", "Create a temporary material from a shader source string." },
{ "Material-mainTexture", "The material's texture." },
{ "Material-mainTextureOffset", "The texture offset of the main texture." },
{ "Material-mainTextureScale", "The texture scale of the main texture." },
{ "Material-passCount", "How many passes are in this material (Read Only)." },
{ "Material-renderQueue", "Render queue of this material." },
{ "Material-shader", "The shader used by the material." },
{ "Material-shaderKeywords", "Additional shader keywords set by this material." },
{ "Material.CopyPropertiesFromMaterial", "Copy properties from other material into this material." },
{ "Material.DisableKeyword", "Unset a shader keyword." },
{ "Material.EnableKeyword", "Set a shader keyword that is enabled by this material." },
{ "Material.GetColor", "Get a named color value." },
{ "Material.GetFloat", "Get a named float value." },
{ "Material.GetInt", "Get a named integer value." },
{ "Material.GetMatrix", "Get a named matrix value from the shader." },
{ "Material.GetTag", "Get the value of material's shader tag." },
{ "Material.GetTexture", "Get a named texture." },
{ "Material.GetTextureOffset", "Gets the placement offset of texture propertyName." },
{ "Material.GetTextureScale", "Gets the placement scale of texture propertyName." },
{ "Material.GetVector", "Get a named vector value." },
{ "Material.HasProperty", "Checks if material's shader has a property of a given name." },
{ "Material.Lerp", "Interpolate properties between two materials." },
{ "Material.SetBuffer", "Set a ComputeBuffer value." },
{ "Material.SetColor", "Set a named color value." },
{ "Material.SetFloat", "Set a named float value." },
{ "Material.SetInt", "Set a named integer value." },
{ "Material.SetMatrix", "Set a named matrix for the shader." },
{ "Material.SetPass", "Activate the given pass for rendering." },
{ "Material.SetTexture", "Set a named texture." },
{ "Material.SetTextureOffset", "Sets the placement offset of texture propertyName." },
{ "Material.SetTextureScale", "Sets the placement scale of texture propertyName." },
{ "Material.SetVector", "Set a named vector value." },
{ "MaterialEditor", "The Unity Material Editor." },
{ "MaterialEditor-isVisible", "Is the current material expanded." },
{ "MaterialEditor.ApplyMaterialPropertyDrawers", "Apply initial MaterialPropertyDrawer values." },
{ "MaterialEditor.Awake", "Called when the Editor is woken up." },
{ "MaterialEditor.ColorProperty", "Draw a property field for a color shader property." },
{ "MaterialEditor.DefaultShaderProperty", "Handles UI for one shader property ignoring any custom drawers." },
{ "MaterialEditor.FloatProperty", "Draw a property field for a float shader property." },
{ "MaterialEditor.GetDefaultPropertyHeight", "Calculate height needed for the property, ignoring custom drawers." },
{ "MaterialEditor.GetMaterialProperties", "Get shader property information of the passed materials." },
{ "MaterialEditor.GetMaterialProperty", "Get information about a single shader property." },
{ "MaterialEditor.GetPropertyHeight", "Calculate height needed for the property." },
{ "MaterialEditor.OnDisable", "Called when the editor is disabled, if overridden please call the base OnDisable() to ensure that the material inspector is set up properly." },
{ "MaterialEditor.OnEnable", "Called when the editor is enabled, if overridden please call the base OnEnable() to ensure that the material inspector is set up properly." },
{ "MaterialEditor.OnInspectorGUI", "Implement specific MaterialEditor GUI code here. If you want to simply extend the existing editor call the base OnInspectorGUI () before doing any custom GUI code." },
{ "MaterialEditor.PropertiesChanged", "Whenever a material property is changed call this function. This will rebuild the inspector and validate the properties." },
{ "MaterialEditor.PropertiesGUI", "Render the standard material properties." },
{ "MaterialEditor.RangeProperty", "Draw a range slider for a range shader property." },
{ "MaterialEditor.RegisterPropertyChangeUndo", "Call this when you change a material property. It will add an undo for the action." },
{ "MaterialEditor.SetShader", "Set the shader of the material." },
{ "MaterialEditor.ShaderProperty", "Handes UI for one shader property." },
{ "MaterialEditor.TextureProperty", "Draw a property field for a texture shader property." },
{ "MaterialEditor.VectorProperty", "Draw a property field for a vector shader property." },
{ "MaterialProperty", "Describes information and value of a single shader property." },
{ "MaterialProperty-colorValue", "Color value of the property." },
{ "MaterialProperty-displayName", "Display name of the property (Read Only)." },
{ "MaterialProperty-flags", "Flags that control how property is displayed (Read Only)." },
{ "MaterialProperty-floatValue", "Float vaue of the property." },
{ "MaterialProperty-hasMixedValue", "Does this property have multiple different values? (Read Only)" },
{ "MaterialProperty-name", "Name of the property (Read Only)." },
{ "MaterialProperty-rangeLimits", "Min/max limits of a ranged float property (Read Only)." },
{ "MaterialProperty-targets", "Material objects being edited by this property (Read Only)." },
{ "MaterialProperty-textureDimension", "Texture dimension (2D, Cubemap etc.) of the property (Read Only)." },
{ "MaterialProperty-textureValue", "Texture value of the property." },
{ "MaterialProperty-type", "Type of the property (Read Only)." },
{ "MaterialProperty-vectorValue", "Vector value of the property." },
{ "MaterialProperty.PropFlags", "Flags that control how a MaterialProperty is displayed." },
{ "MaterialProperty.PropFlags.HideInInspector", "Do not show the property in inspector." },
{ "MaterialProperty.PropFlags.None", "No flags are set." },
{ "MaterialProperty.PropFlags.PerRendererData", "Texture value for this property will be queried from renderer's MaterialPropertyBlock, instead of from the material. This corresponds to \"[PerRendererData]\" attribute in front of property in the shader code." },
{ "MaterialProperty.PropType", "Material property type." },
{ "MaterialProperty.PropType.Color", "Color property." },
{ "MaterialProperty.PropType.Float", "Float property." },
{ "MaterialProperty.PropType.Range", "Ranged float (with min/max values) property." },
{ "MaterialProperty.PropType.Texture", "Texture property." },
{ "MaterialProperty.PropType.Vector", "Vector property." },
{ "MaterialProperty.TexDim", "Texture dimension of a property." },
{ "MaterialProperty.TexDim.Any", "Texture property accepts any texture type." },
{ "MaterialProperty.TexDim.Cube", "Cubemap property." },
{ "MaterialProperty.TexDim.None", "No texture type is set." },
{ "MaterialProperty.TexDim.Tex2D", "Texture2D property." },
{ "MaterialProperty.TexDim.Tex3D", "Texture3D property." },
{ "MaterialPropertyBlock", "A block of material values to apply." },
{ "MaterialPropertyBlock.AddColor", "Add a color material property." },
{ "MaterialPropertyBlock.AddFloat", "Add a float material property." },
{ "MaterialPropertyBlock.AddMatrix", "Add a matrix material property." },
{ "MaterialPropertyBlock.AddTexture", "Add a texture material property." },
{ "MaterialPropertyBlock.AddVector", "Add a vector material property." },
{ "MaterialPropertyBlock.Clear", "Clear material property values." },
{ "MaterialPropertyBlock.GetFloat", "Get a float from the property block." },
{ "MaterialPropertyBlock.GetMatrix", "Get a matrix from the property block." },
{ "MaterialPropertyBlock.GetTexture", "Get a texture from the property block." },
{ "MaterialPropertyBlock.GetVector", "Get a vector from the property block." },
{ "MaterialPropertyDrawer", "Base class to derive custom material property drawers from." },
{ "MaterialPropertyDrawer.Apply", "Apply extra initial values to the material." },
{ "MaterialPropertyDrawer.GetPropertyHeight", "Override this method to specify how tall the GUI for this property is in pixels." },
{ "MaterialPropertyDrawer.OnGUI", "Override this method to make your own GUI for the property." },
{ "Mathf", "A collection of common math functions." },
{ "Mathf.Abs", "Returns the absolute value of f." },
{ "Mathf.Acos", "Returns the arc-cosine of f - the angle in radians whose cosine is f." },
{ "Mathf.Approximately", "Compares two floating point values if they are similar." },
{ "Mathf.Asin", "Returns the arc-sine of f - the angle in radians whose sine is f." },
{ "Mathf.Atan", "Returns the arc-tangent of f - the angle in radians whose tangent is f." },
{ "Mathf.Atan2", "Returns the angle in radians whose Tan is y/x." },
{ "Mathf.Ceil", "Returns the smallest integer greater to or equal to f." },
{ "Mathf.CeilToInt", "Returns the smallest integer greater to or equal to f." },
{ "Mathf.Clamp", "Clamps a value between a minimum float and maximum float value." },
{ "Mathf.Clamp01", "Clamps value between 0 and 1 and returns value." },
{ "Mathf.ClosestPowerOfTwo", "Returns the closest power of two value." },
{ "Mathf.Cos", "Returns the cosine of angle f in radians." },
{ "Mathf.Deg2Rad", "Degrees-to-radians conversion constant (Read Only)." },
{ "Mathf.DeltaAngle", "Calculates the shortest difference between two given angles." },
{ "Mathf.Epsilon", "A tiny floating point value (Read Only)." },
{ "Mathf.Exp", "Returns e raised to the specified power." },
{ "Mathf.Floor", "Returns the largest integer smaller to or equal to f." },
{ "Mathf.FloorToInt", "Returns the largest integer smaller to or equal to f." },
{ "Mathf.GammaToLinearSpace", "Converts the given value from gamma to linear color space." },
{ "Mathf.Infinity", "A representation of positive infinity (Read Only)." },
{ "Mathf.InverseLerp", "Calculates the Lerp parameter between of two values." },
{ "Mathf.IsPowerOfTwo", "Returns true if the value is power of two." },
{ "Mathf.Lerp", "Interpolates between a and b by t. t is clamped between 0 and 1." },
{ "Mathf.LerpAngle", "Same as Lerp but makes sure the values interpolate correctly when they wrap around 360 degrees." },
{ "Mathf.LinearToGammaSpace", "Converts the given value from linear to gamma color space." },
{ "Mathf.Log", "Returns the logarithm of a specified number in a specified base." },
{ "Mathf.Log10", "Returns the base 10 logarithm of a specified number." },
{ "Mathf.Max", "Returns largest of two or more values." },
{ "Mathf.Min", "Returns the smallest of two or more values." },
{ "Mathf.MoveTowards", "Moves a value current towards target." },
{ "Mathf.MoveTowardsAngle", "Same as MoveTowards but makes sure the values interpolate correctly when they wrap around 360 degrees." },
{ "Mathf.NegativeInfinity", "A representation of negative infinity (Read Only)." },
{ "Mathf.NextPowerOfTwo", "Returns the next power of two value." },
{ "Mathf.PerlinNoise", "Generate 2D Perlin noise." },
{ "Mathf.PI", "The infamous 3.14159265358979... value (Read Only)." },
{ "Mathf.PingPong", "PingPongs the value t, so that it is never larger than length and never smaller than 0." },
{ "Mathf.Pow", "Returns f raised to power p." },
{ "Mathf.Rad2Deg", "Radians-to-degrees conversion constant (Read Only)." },
{ "Mathf.Repeat", "Loops the value t, so that it is never larger than length and never smaller than 0." },
{ "Mathf.Round", "Returns f rounded to the nearest integer." },
{ "Mathf.RoundToInt", "Returns f rounded to the nearest integer." },
{ "Mathf.Sign", "Returns the sign of f." },
{ "Mathf.Sin", "Returns the sine of angle f in radians." },
{ "Mathf.SmoothDamp", "Gradually changes a value towards a desired goal over time." },
{ "Mathf.SmoothDampAngle", "Gradually changes an angle given in degrees towards a desired goal angle over time." },
{ "Mathf.SmoothStep", "Interpolates between min and max with smoothing at the limits." },
{ "Mathf.Sqrt", "Returns square root of f." },
{ "Mathf.Tan", "Returns the tangent of angle f in radians." },
{ "Matrix4x4", "A standard 4x4 transformation matrix." },
{ "Matrix4x4-identity", "Returns the identity matrix (Read Only)." },
{ "Matrix4x4-inverse", "The inverse of this matrix (Read Only)." },
{ "Matrix4x4-isIdentity", "Is this the identity matrix?" },
{ "Matrix4x4-operator_multiply", "Multiplies two matrices." },
{ "Matrix4x4-transpose", "Returns the transpose of this matrix (Read Only)." },
{ "Matrix4x4-zero", "Returns a matrix with all elements set to zero (Read Only)." },
{ "Matrix4x4.GetColumn", "Get a column of the matrix." },
{ "Matrix4x4.GetRow", "Returns a row of the matrix." },
{ "Matrix4x4.Index_operator", "Access element at [row, column]." },
{ "Matrix4x4.MultiplyPoint", "Transforms a position by this matrix (generic)." },
{ "Matrix4x4.MultiplyPoint3x4", "Transforms a position by this matrix (fast)." },
{ "Matrix4x4.MultiplyVector", "Transforms a direction by this matrix." },
{ "Matrix4x4.Ortho", "Creates an orthogonal projection matrix." },
{ "Matrix4x4.Perspective", "Creates a perspective projection matrix." },
{ "Matrix4x4.Scale", "Creates a scaling matrix." },
{ "Matrix4x4.SetColumn", "Sets a column of the matrix." },
{ "Matrix4x4.SetRow", "Sets a row of the matrix." },
{ "Matrix4x4.SetTRS", "Sets this matrix to a translation, rotation and scaling matrix." },
{ "Matrix4x4.ToString", "Returns a nicely formatted string for this matrix." },
{ "Matrix4x4.TRS", "Creates a translation, rotation and scaling matrix." },
{ "MenuCommand", "Used to extract the context for a MenuItem. MenuCommand objects are passed to custom menu item functions defined using the MenuItem attribute." },
{ "MenuCommand-context", "Context is the object that is the target of a menu command." },
{ "MenuCommand-ctor", "Creates a new MenuCommand object." },
{ "MenuCommand-userData", "An integer for passing custom information to a menu item." },
{ "MenuItem", "The MenuItem attribute allows you to add menu items to the main menu and inspector context menus." },
{ "MenuItem-ctor", "Creates a menu item and invokes the static function following it, when the menu item is selected." },
{ "Mesh", "A class that allows creating or modifying meshes from scripts." },
{ "Mesh-bindposes", "The bind poses. The bind pose at each index refers to the bone with the same index." },
{ "Mesh-blendShapeCount", "Returns BlendShape count on this mesh." },
{ "Mesh-boneWeights", "The bone weights of each vertex." },
{ "Mesh-bounds", "The bounding volume of the mesh." },
{ "Mesh-colors", "Vertex colors of the mesh." },
{ "Mesh-colors32", "Vertex colors of the mesh." },
{ "Mesh-ctor", "Creates an empty mesh." },
{ "Mesh-isReadable", "Returns state of the Read/Write Enabled checkbox when model was imported." },
{ "Mesh-normals", "The normals of the mesh." },
{ "Mesh-subMeshCount", "The number of submeshes. Every material has a separate triangle list." },
{ "Mesh-tangents", "The tangents of the mesh." },
{ "Mesh-triangles", "An array containing all triangles in the mesh." },
{ "Mesh-uv", "The base texture coordinates of the mesh." },
{ "Mesh-uv2", "The second texture coordinate set of the mesh, if present." },
{ "Mesh-vertexCount", "Returns the number of vertices in the mesh (Read Only)." },
{ "Mesh-vertices", "Returns a copy of the vertex positions or assigns a new vertex positions array." },
{ "Mesh.Clear", "Clears all vertex data and all triangle indices." },
{ "Mesh.CombineMeshes", "Combines several meshes into this mesh." },
{ "Mesh.GetBlendShapeName", "Returns name of BlendShape by given index." },
{ "Mesh.GetIndices", "Returns the index buffer for the submesh." },
{ "Mesh.GetTopology", "Gets the topology of a submesh." },
{ "Mesh.GetTriangles", "Returns the triangle list for the submesh." },
{ "Mesh.MarkDynamic", "Optimize mesh for frequent updates." },
{ "Mesh.Optimize", "Optimizes the mesh for display." },
{ "Mesh.RecalculateBounds", "Recalculate the bounding volume of the mesh from the vertices." },
{ "Mesh.RecalculateNormals", "Recalculates the normals of the mesh from the triangles and vertices." },
{ "Mesh.SetIndices", "Sets the index buffer for the submesh." },
{ "Mesh.SetTriangles", "Sets the triangle list for the submesh." },
{ "MeshCollider", "A mesh collider allows you to do collision detection between meshes and primitives." },
{ "MeshCollider-convex", "Use a convex collider from the mesh." },
{ "MeshCollider-sharedMesh", "The mesh object used for collision detection." },
{ "MeshCollider-smoothSphereCollisions", "Uses interpolated normals for sphere collisions instead of flat polygonal normals." },
{ "MeshFilter", "A class to access the Mesh of the mesh filter." },
{ "MeshFilter-mesh", "Returns the instantiated Mesh assigned to the mesh filter." },
{ "MeshFilter-sharedMesh", "Returns the shared mesh of the mesh filter." },
{ "MeshRenderer", "Renders meshes inserted by the MeshFilter or TextMesh." },
{ "MeshTopology", "Topology of Mesh faces." },
{ "MeshTopology.Lines", "Mesh is made from lines." },
{ "MeshTopology.LineStrip", "Mesh is a line strip." },
{ "MeshTopology.Points", "Mesh is made from points." },
{ "MeshTopology.Quads", "Mesh is made from quads." },
{ "MeshTopology.Triangles", "Mesh is made from triangles." },
{ "MeshUtility", "Various utilities for mesh manipulation." },
{ "MeshUtility.GetMeshCompression", "Returns the mesh compression setting for a Mesh." },
{ "MeshUtility.Optimize", "Optimizes the mesh for GPU access." },
{ "MeshUtility.SetMeshCompression", "Change the mesh compression setting for a mesh." },
{ "MeshUtility.SetPerTriangleUV2", "Will insert per-triangle uv2 in mesh and handle vertex splitting etc." },
{ "MessageType", "User message types." },
{ "MessageType.Error", "Error message." },
{ "MessageType.Info", "Info message." },
{ "MessageType.None", "Neutral message." },
{ "MessageType.Warning", "Warning message." },
{ "Microphone", "Use this class to record to an AudioClip using a connected microphone." },
{ "Microphone-devices", "A list of available microphone devices, identified by name." },
{ "Microphone.End", "Stops recording." },
{ "Microphone.GetDeviceCaps", "Get the frequency capabilities of a device." },
{ "Microphone.GetPosition", "Get the position in samples of the recording." },
{ "Microphone.IsRecording", "Query if a device is currently recording." },
{ "Microphone.Start", "Start Recording with device." },
{ "ModelImporter", "Model importer lets you modify model import settings from editor scripts." },
{ "ModelImporter-addCollider", "Add mesh colliders to imported meshes." },
{ "ModelImporter-animationCompression", "Animation compression setting." },
{ "ModelImporter-animationPositionError", "Allowed error of animation position compression." },
{ "ModelImporter-animationRotationError", "Allowed error of animation rotation compression." },
{ "ModelImporter-animationScaleError", "Allowed error of animation scale compression." },
{ "ModelImporter-animationType", "Animator generation mode." },
{ "ModelImporter-animationWrapMode", "The default wrap mode for the generated animation clips." },
{ "ModelImporter-bakeIK", "Bake Inverse Kinematics (IK) when importing." },
{ "ModelImporter-clipAnimations", "Animation clips to split animation into." },
{ "ModelImporter-extraExposedTransformPaths", "Animation optimization setting." },
{ "ModelImporter-generateAnimations", "Animation generation options." },
{ "ModelImporter-generateSecondaryUV", "Generate secondary UV set for lightmapping." },
{ "ModelImporter-globalScale", "Global scale factor for importing." },
{ "ModelImporter-importAnimation", "Import animation from file." },
{ "ModelImporter-importBlendShapes", "Controls import of BlendShapes." },
{ "ModelImporter-importMaterials", "Import materials from file." },
{ "ModelImporter-isBakeIKSupported", "Is Bake Inverse Kinematics (IK) supported by this importer." },
{ "ModelImporter-isReadable", "Are mesh vertices and indices accessible from script?" },
{ "ModelImporter-isTangentImportSupported", "Is import of tangents supported by this importer." },
{ "ModelImporter-isUseFileUnitsSupported", "Is useFileUnits supported for this asset." },
{ "ModelImporter-materialName", "Material naming setting." },
{ "ModelImporter-materialSearch", "Existing material search setting." },
{ "ModelImporter-meshCompression", "Mesh compression setting." },
{ "ModelImporter-normalImportMode", "Normals import mode." },
{ "ModelImporter-normalSmoothingAngle", "Smoothing angle for calculating normals." },
{ "ModelImporter-optimizeGameObjects", "Animation optimization setting." },
{ "ModelImporter-optimizeMesh", "Vertex optimization setting." },
{ "ModelImporter-referencedClips", "Generates the list of all imported Animations." },
{ "ModelImporter-secondaryUVAngleDistortion", "Threshold for angle distortion when generating secondary UV." },
{ "ModelImporter-secondaryUVAreaDistortion", "Threshold for area distortion when generating secondary UV." },
{ "ModelImporter-secondaryUVHardAngle", "Hard angle for generating secondary UV." },
{ "ModelImporter-secondaryUVPackMargin", "Margin to be left between charts when packing secondary UV." },
{ "ModelImporter-splitTangentsAcrossSeams", "Should tangents be split across UV seams." },
{ "ModelImporter-swapUVChannels", "Swap primary and secondary UV channels when importing." },
{ "ModelImporter-tangentImportMode", "Tangents import mode." },
{ "ModelImporter-transformPaths", "Generates the list of all imported Transforms." },
{ "ModelImporter-useFileUnits", "Detect file units and import as 1FileUnit=1UnityUnit, otherwise it will import as 1cm=1UnityUnit." },
{ "ModelImporterAnimationCompression", "Animation compression options for ModelImporter." },
{ "ModelImporterAnimationCompression.KeyframeReduction", "Perform keyframe reduction (default)." },
{ "ModelImporterAnimationCompression.KeyframeReductionAndCompression", "Perform keyframe reduction and compression." },
{ "ModelImporterAnimationCompression.Off", "No animation compression." },
{ "ModelImporterAnimationType", "Animation mode for ModelImporter." },
{ "ModelImporterAnimationType.Generic", "Generate a generic animator." },
{ "ModelImporterAnimationType.Human", "Generate a human animator." },
{ "ModelImporterAnimationType.Legacy", "Generate a legacy animation type." },
{ "ModelImporterAnimationType.None", "Generate no animation data." },
{ "ModelImporterClipAnimation", "Animation clips to split animation into." },
{ "ModelImporterClipAnimation-cycleOffset", "Offset to the cycle of a looping animation, if a different time in it is desired to be the start." },
{ "ModelImporterClipAnimation-firstFrame", "First frame of the clip." },
{ "ModelImporterClipAnimation-heightFromFeet", "Keeps the feet aligned with the root transform position." },
{ "ModelImporterClipAnimation-heightOffset", "Offset to the vertical root position." },
{ "ModelImporterClipAnimation-keepOriginalOrientation", "Keeps the vertical position as it is authored in the source file." },
{ "ModelImporterClipAnimation-keepOriginalPositionXZ", "Keeps the vertical position as it is authored in the source file." },
{ "ModelImporterClipAnimation-keepOriginalPositionY", "Keeps the vertical position as it is authored in the source file." },
{ "ModelImporterClipAnimation-lastFrame", "Last frame of the clip." },
{ "ModelImporterClipAnimation-lockRootHeightY", "Enable to make vertical root motion be baked into the movement of the bones. Disable to make vertical root motion be stored as root motion." },
{ "ModelImporterClipAnimation-lockRootPositionXZ", "Enable to make horizontal root motion be baked into the movement of the bones. Disable to make horizontal root motion be stored as root motion." },
{ "ModelImporterClipAnimation-lockRootRotation", "Enable to make root rotation be baked into the movement of the bones. Disable to make root rotation be stored as root motion." },
{ "ModelImporterClipAnimation-loop", "Is the clip a looping animation?" },
{ "ModelImporterClipAnimation-loopPose", "Enable to make the motion loop seamlessly." },
{ "ModelImporterClipAnimation-loopTime", "Enable to make the clip loop." },
{ "ModelImporterClipAnimation-maskSource", "The AvatarMask used to mask transforms during the import process." },
{ "ModelImporterClipAnimation-maskType", "Define mask type." },
{ "ModelImporterClipAnimation-mirror", "Mirror left and right in this clip." },
{ "ModelImporterClipAnimation-name", "Clip name." },
{ "ModelImporterClipAnimation-rotationOffset", "Offset in degrees to the root rotation." },
{ "ModelImporterClipAnimation-takeName", "Take name." },
{ "ModelImporterClipAnimation-wrapMode", "The wrap mode of the animation." },
{ "ModelImporterGenerateAnimations", "Animation generation options for ModelImporter. These options relate to the legacy Animation system, they should only be used when ModelImporter.animationType==ModelImporterAnimationType.Legacy." },
{ "ModelImporterGenerateAnimations.GenerateAnimations", "Default animation import mode (All animations are stored in the root object)." },
{ "ModelImporterGenerateAnimations.InNodes", "Generate animations in the objects that animate." },
{ "ModelImporterGenerateAnimations.InOriginalRoots", "Generate animations in the root objects of the animation package." },
{ "ModelImporterGenerateAnimations.InRoot", "Generate animations in the transform root objects." },
{ "ModelImporterGenerateAnimations.None", "Do not generate animations." },
{ "ModelImporterMaterialName", "Material naming options for ModelImporter." },
{ "ModelImporterMaterialName.BasedOnMaterialName", "Use a material name of the form <materialName>.mat." },
{ "ModelImporterMaterialName.BasedOnModelNameAndMaterialName", "Use material names in the form <modelFileName>-<materialName>.mat." },
{ "ModelImporterMaterialName.BasedOnTextureName", "Use material names in the form <textureName>.mat." },
{ "ModelImporterMaterialSearch", "Material search options for ModelImporter." },
{ "ModelImporterMaterialSearch.Everywhere", "Searh in all project." },
{ "ModelImporterMaterialSearch.Local", "Searh in local Materials forlder." },
{ "ModelImporterMaterialSearch.RecursiveUp", "Recursive-up search in Materials forlders." },
{ "ModelImporterMeshCompression", "Mesh compression options for ModelImporter." },
{ "ModelImporterMeshCompression.High", "High amount of mesh compression." },
{ "ModelImporterMeshCompression.Low", "Low amount of mesh compression." },
{ "ModelImporterMeshCompression.Medium", "Medium amount of mesh compression." },
{ "ModelImporterMeshCompression.Off", "No mesh compression (default)." },
{ "ModelImporterTangentSpaceMode", "Animation generation options for ModelImporter." },
{ "ModelImporterTangentSpaceMode.Calculate", "Calculate normals/tangents." },
{ "ModelImporterTangentSpaceMode.Import", "Import normals/tangents from file." },
{ "ModelImporterTangentSpaceMode.None", "Strip normals/tangents." },
{ "MonoBehaviour", "MonoBehaviour is the base class every script derives from." },
{ "MonoBehaviour-print", "Logs message to the Unity Console (identical to Debug.Log)." },
{ "MonoBehaviour-useGUILayout", "Disabling this lets you skip the GUI layout phase." },
{ "MonoBehaviour.Awake", "Awake is called when the script instance is being loaded." },
{ "MonoBehaviour.CancelInvoke", "Cancels all Invoke calls on this MonoBehaviour." },
{ "MonoBehaviour.FixedUpdate", "This function is called every fixed framerate frame, if the MonoBehaviour is enabled." },
{ "MonoBehaviour.Invoke", "Invokes the method methodName in time seconds." },
{ "MonoBehaviour.InvokeRepeating", "Invokes the method methodName in time seconds, then repeatedly every repeatRate seconds." },
{ "MonoBehaviour.IsInvoking", "Is any invoke on methodName pending?" },
{ "MonoBehaviour.LateUpdate", "LateUpdate is called every frame, if the Behaviour is enabled." },
{ "MonoBehaviour.OnAnimatorIK", "Callback for setting up animation IK (inverse kinematics)." },
{ "MonoBehaviour.OnAnimatorMove", "Callback for processing animation movements for modifying root motion." },
{ "MonoBehaviour.OnApplicationFocus", "Sent to all game objects when the player gets or loses focus." },
{ "MonoBehaviour.OnApplicationPause", "Sent to all game objects when the player pauses." },
{ "MonoBehaviour.OnApplicationQuit", "Sent to all game objects before the application is quit." },
{ "MonoBehaviour.OnAudioFilterRead", "If OnAudioFilterRead is implemented, Unity will insert a custom filter into the audio DSP chain." },
{ "MonoBehaviour.OnBecameInvisible", "OnBecameInvisible is called when the renderer is no longer visible by any camera." },
{ "MonoBehaviour.OnBecameVisible", "OnBecameVisible is called when the renderer became visible by any camera." },
{ "MonoBehaviour.OnCollisionEnter", "OnCollisionEnter is called when this collider/rigidbody has begun touching another rigidbody/collider." },
{ "MonoBehaviour.OnCollisionEnter2D", "Sent when an incoming collider makes contact with this object's collider (2D physics only)." },
{ "MonoBehaviour.OnCollisionExit", "OnCollisionExit is called when this collider/rigidbody has stopped touching another rigidbody/collider." },
{ "MonoBehaviour.OnCollisionExit2D", "Sent when a collider on another object stops touching this object's collider (2D physics only)." },
{ "MonoBehaviour.OnCollisionStay", "OnCollisionStay is called once per frame for every collider/rigidbody that is touching rigidbody/collider." },
{ "MonoBehaviour.OnCollisionStay2D", "Sent each frame where a collider on another object is touching this object's collider (2D physics only)." },
{ "MonoBehaviour.OnConnectedToServer", "Called on the client when you have successfully connected to a server." },
{ "MonoBehaviour.OnControllerColliderHit", "OnControllerColliderHit is called when the controller hits a collider while performing a Move." },
{ "MonoBehaviour.OnDestroy", "This function is called when the MonoBehaviour will be destroyed." },
{ "MonoBehaviour.OnDisable", "This function is called when the behaviour becomes disabled () or inactive." },
{ "MonoBehaviour.OnDisconnectedFromServer", "Called on the client when the connection was lost or you disconnected from the server." },
{ "MonoBehaviour.OnDrawGizmos", "Implement OnDrawGizmos if you want to draw gizmos that are also pickable and always drawn." },
{ "MonoBehaviour.OnDrawGizmosSelected", "Implement this OnDrawGizmosSelected if you want to draw gizmos only if the object is selected." },
{ "MonoBehaviour.OnEnable", "This function is called when the object becomes enabled and active." },
{ "MonoBehaviour.OnFailedToConnect", "Called on the client when a connection attempt fails for some reason." },
{ "MonoBehaviour.OnFailedToConnectToMasterServer", "Called on clients or servers when there is a problem connecting to the MasterServer." },
{ "MonoBehaviour.OnGUI", "OnGUI is called for rendering and handling GUI events." },
{ "MonoBehaviour.OnJointBreak", "Called when a joint attached to the same game object broke." },
{ "MonoBehaviour.OnLevelWasLoaded", "This function is called after a new level was loaded." },
{ "MonoBehaviour.OnMasterServerEvent", "Called on clients or servers when reporting events from the MasterServer." },
{ "MonoBehaviour.OnMouseDown", "OnMouseDown is called when the user has pressed the mouse button while over the GUIElement or Collider." },
{ "MonoBehaviour.OnMouseDrag", "OnMouseDrag is called when the user has clicked on a GUIElement or Collider and is still holding down the mouse." },
{ "MonoBehaviour.OnMouseEnter", "OnMouseEnter is called when the mouse entered the GUIElement or Collider." },
{ "MonoBehaviour.OnMouseExit", "OnMouseExit is called when the mouse is not any longer over the GUIElement or Collider." },
{ "MonoBehaviour.OnMouseOver", "OnMouseOver is called every frame while the mouse is over the GUIElement or Collider." },
{ "MonoBehaviour.OnMouseUp", "OnMouseUp is called when the user has released the mouse button." },
{ "MonoBehaviour.OnMouseUpAsButton", "OnMouseUpAsButton is only called when the mouse is released over the same GUIElement or Collider as it was pressed." },
{ "MonoBehaviour.OnNetworkInstantiate", "Called on objects which have been network instantiated with Network.Instantiate." },
{ "MonoBehaviour.OnParticleCollision", "OnParticleCollision is called when a particle hits a collider." },
{ "MonoBehaviour.OnPlayerConnected", "Called on the server whenever a new player has successfully connected." },
{ "MonoBehaviour.OnPlayerDisconnected", "Called on the server whenever a player disconnected from the server." },
{ "MonoBehaviour.OnPostRender", "OnPostRender is called after a camera finished rendering the scene." },
{ "MonoBehaviour.OnPreCull", "OnPreCull is called before a camera culls the scene." },
{ "MonoBehaviour.OnPreRender", "OnPreRender is called before a camera starts rendering the scene." },
{ "MonoBehaviour.OnRenderImage", "OnRenderImage is called after all rendering is complete to render image." },
{ "MonoBehaviour.OnRenderObject", "OnRenderObject is called after camera has rendered the scene." },
{ "MonoBehaviour.OnSerializeNetworkView", "Used to customize synchronization of variables in a script watched by a network view." },
{ "MonoBehaviour.OnServerInitialized", "Called on the server whenever a Network.InitializeServer was invoked and has completed." },
{ "MonoBehaviour.OnTriggerEnter", "OnTriggerEnter is called when the Collider other enters the trigger." },
{ "MonoBehaviour.OnTriggerEnter2D", "Sent when another object enters a trigger collider attached to this object (2D physics only)." },
{ "MonoBehaviour.OnTriggerExit", "OnTriggerExit is called when the Collider other has stopped touching the trigger." },
{ "MonoBehaviour.OnTriggerExit2D", "Sent when another object leaves a trigger collider attached to this object (2D physics only)." },
{ "MonoBehaviour.OnTriggerStay", "OnTriggerStay is called once per frame for every Collider other that is touching the trigger." },
{ "MonoBehaviour.OnTriggerStay2D", "Sent each frame where another object is within a trigger collider attached to this object (2D physics only)." },
{ "MonoBehaviour.OnValidate", "This function is called when the script is loaded or a value is changed in the inspector (Called in the editor only)." },
{ "MonoBehaviour.OnWillRenderObject", "OnWillRenderObject is called once for each camera if the object is visible." },
{ "MonoBehaviour.Reset", "Reset to default values." },
{ "MonoBehaviour.Start", "Start is called on the frame when a script is enabled just before any of the Update methods is called the first time." },
{ "MonoBehaviour.StartCoroutine", "Starts a coroutine." },
{ "MonoBehaviour.StopAllCoroutines", "Stops all coroutines running on this behaviour." },
{ "MonoBehaviour.StopCoroutine", "Stops all coroutines named methodName running on this behaviour." },
{ "MonoBehaviour.Update", "Update is called every frame, if the MonoBehaviour is enabled." },
{ "MonoScript", "Representation of Script assets." },
{ "MonoScript.FromMonoBehaviour", "Returns the MonoScript object containing specified MonoBehaviour." },
{ "MonoScript.FromScriptableObject", "Returns the MonoScript object containing specified ScriptableObject." },
{ "MonoScript.GetClass", "Returns the System.Type object of the class implemented by this script." },
{ "Motion", "Base class for AnimationClips and BlendTrees." },
{ "MouseCursor", "Custom mouse cursor shapes used with EditorGUIUtility.AddCursorRect." },
{ "MouseCursor.Arrow", "Normal pointer arrow." },
{ "MouseCursor.ArrowMinus", "Arrow with the minus symbol next to it." },
{ "MouseCursor.ArrowPlus", "Arrow with the plus symbol next to it." },
{ "MouseCursor.CustomCursor", "The current user defined cursor." },
{ "MouseCursor.FPS", "Cursor with an eye and stylized arrow keys for FPS navigation." },
{ "MouseCursor.Link", "Arrow with a Link badge (for assigning pointers)." },
{ "MouseCursor.MoveArrow", "Arrow with the move symbol next to it for the sceneview." },
{ "MouseCursor.Orbit", "Cursor with an eye for orbit." },
{ "MouseCursor.Pan", "Cursor with a dragging hand for pan." },
{ "MouseCursor.ResizeHorizontal", "Horizontal resize arrows." },
{ "MouseCursor.ResizeUpLeft", "Resize up-Left for window edges." },
{ "MouseCursor.ResizeUpRight", "Resize up-right for window edges." },
{ "MouseCursor.ResizeVertical", "Vertical resize arrows." },
{ "MouseCursor.RotateArrow", "Arrow with the rotate symbol next to it for the sceneview." },
{ "MouseCursor.ScaleArrow", "Arrow with the scale symbol next to it for the sceneview." },
{ "MouseCursor.SlideArrow", "Arrow with small arrows for indicating sliding at number fields." },
{ "MouseCursor.SplitResizeLeftRight", "Left-Right resize arrows for window splitters." },
{ "MouseCursor.SplitResizeUpDown", "Up-Down resize arrows for window splitters." },
{ "MouseCursor.Text", "Text cursor." },
{ "MouseCursor.Zoom", "Cursor with a magnifying glass for zoom." },
{ "MovieImporter", "AssetImporter for importing MovieTextures." },
{ "MovieImporter-duration", "Duration of the Movie to be imported in seconds." },
{ "MovieImporter-linearTexture", "Is this a linear texture or an sRGB texture (Only used when performing linear rendering)." },
{ "MovieImporter-quality", "Quality setting to use when importing the movie. This is a float value from 0 to 1." },
{ "MovieTexture", "Movie Textures (Pro only) are textures onto which movies are played back." },
{ "MovieTexture-audioClip", "Returns the AudioClip belonging to the MovieTexture." },
{ "MovieTexture-duration", "The time, in seconds, that the movie takes to play back completely." },
{ "MovieTexture-isPlaying", "Returns whether the movie is playing or not." },
{ "MovieTexture-isReadyToPlay", "If the movie is downloading from a web site, this returns if enough data has been downloaded so playback should be able to start without interruptions." },
{ "MovieTexture-loop", "Set this to true to make the movie loop." },
{ "MovieTexture.Pause", "Pauses playing the movie." },
{ "MovieTexture.Play", "Starts playing the movie." },
{ "MovieTexture.Stop", "Stops playing the movie, and rewinds it to the beginning." },
{ "MultilineAttribute", "Attribute to make a string be edited with a multi-line textfield." },
{ "MultilineAttribute-ctor", "Attribute used to make a string value be shown in a multiline textarea." },
{ "NavMesh", "Navigation mesh." },
{ "NavMesh.CalculatePath", "Calculate a path between two points and store the resulting path." },
{ "NavMesh.CalculateTriangulation", "Triangulation of the current navmesh." },
{ "NavMesh.FindClosestEdge", "Locate the closest NavMesh edge from a point on the NavMesh." },
{ "NavMesh.GetLayerCost", "Gets the cost for traversing over geometry of the layer type on all agents." },
{ "NavMesh.GetNavMeshLayerFromName", "Returns the layer index for a named layer." },
{ "NavMesh.Raycast", "Trace a line between two points on the NavMesh." },
{ "NavMesh.SamplePosition", "Sample the NavMesh closest to the point specified." },
{ "NavMesh.SetLayerCost", "Sets the cost for traversing over geometry of the layer type on all agents." },
{ "NavMeshAgent", "Navigation mesh agent." },
{ "NavMeshAgent-acceleration", "The maximum acceleration of an agent as it follows a path, given in units / sec^2." },
{ "NavMeshAgent-angularSpeed", "Maximum turning speed in (deg/s) while following a path." },
{ "NavMeshAgent-autoBraking", "Should the agent brake automatically to avoid overshooting the destination point?" },
{ "NavMeshAgent-autoRepath", "Should the agent attempt to acquire a new path if the existing path becomes invalid?" },
{ "NavMeshAgent-autoTraverseOffMeshLink", "Should the agent move via OffMeshLinks automatically?" },
{ "NavMeshAgent-avoidancePriority", "The avoidance priority level." },
{ "NavMeshAgent-baseOffset", "The relative vertical displacement of the owning GameObject." },
{ "NavMeshAgent-currentOffMeshLinkData", "The current OffMeshLinkData." },
{ "NavMeshAgent-desiredVelocity", "The desired velocity of the agent including any potential contribution from avoidance. (Read Only)" },
{ "NavMeshAgent-destination", "Destination point for the agent to navigate towards." },
{ "NavMeshAgent-hasPath", "Does the agent currently have a path? (Read Only)" },
{ "NavMeshAgent-height", "The height of the agent for purposes of passing under obstacles, etc." },
{ "NavMeshAgent-isOnOffMeshLink", "Is the agent currently positioned on an OffMeshLink? (Read Only)" },
{ "NavMeshAgent-isPathStale", "Is the current path stale. (Read Only)" },
{ "NavMeshAgent-nextOffMeshLinkData", "The next OffMeshLinkData on the current path." },
{ "NavMeshAgent-nextPosition", "The next position on the path." },
{ "NavMeshAgent-obstacleAvoidanceType", "The level of quality of avoidance." },
{ "NavMeshAgent-path", "Property to get and set the current path." },
{ "NavMeshAgent-pathPending", "Is a path in the process of being computed but not yet ready? (Read Only)" },
{ "NavMeshAgent-pathStatus", "The status of the current path (complete, partial or invalid)." },
{ "NavMeshAgent-radius", "The avoidance radius for the agent." },
{ "NavMeshAgent-remainingDistance", "The distance between the agent's position and the destination on the current path. (Read Only)" },
{ "NavMeshAgent-speed", "Maximum movement speed when following a path." },
{ "NavMeshAgent-steeringTarget", "The current steering target - usually the next corner or end point of the current path. (Read Only)" },
{ "NavMeshAgent-stoppingDistance", "Stop within this distance from the target position." },
{ "NavMeshAgent-updatePosition", "Should the agent update the transform position?" },
{ "NavMeshAgent-updateRotation", "Should the agent update the transform orientation?" },
{ "NavMeshAgent-velocity", "The current velocity of the NavMeshAgent component." },
{ "NavMeshAgent-walkableMask", "Specifies which NavMesh layers are passable (bitfield). Changing walkableMask will make the path stale (see isPathStale)." },
{ "NavMeshAgent.ActivateCurrentOffMeshLink", "Enables or disables the current off-mesh link." },
{ "NavMeshAgent.CalculatePath", "Calculate a path to a specified point and store the resulting path." },
{ "NavMeshAgent.CompleteOffMeshLink", "Follow the current OffMeshLink." },
{ "NavMeshAgent.FindClosestEdge", "Locate the closest NavMesh edge." },
{ "NavMeshAgent.GetLayerCost", "Gets the cost for crossing ground of a particular type." },
{ "NavMeshAgent.Move", "Apply relative movement to current position." },
{ "NavMeshAgent.Raycast", "Trace a straight path towards a target postion in the NavMesh without moving the agent." },
{ "NavMeshAgent.ResetPath", "Clears the current path." },
{ "NavMeshAgent.Resume", "Resumes the movement along the current path after a pause." },
{ "NavMeshAgent.SamplePathPosition", "Sample a position along the current path." },
{ "NavMeshAgent.SetDestination", "Sets or updates the destination thus triggering the calculation for a new path." },
{ "NavMeshAgent.SetLayerCost", "Sets the cost for traversing over geometry of the layer type." },
{ "NavMeshAgent.SetPath", "Assign a new path to this agent." },
{ "NavMeshAgent.Stop", "Stop movement of this agent along its current path." },
{ "NavMeshAgent.Warp", "Warps agent to the provided position." },
{ "NavMeshBuilder", "Navigation mesh builder interface." },
{ "NavMeshBuilder-isRunning", "Returns true if an asynchronous build is still running." },
{ "NavMeshBuilder.BuildNavMesh", "Build the Navmesh." },
{ "NavMeshBuilder.BuildNavMeshAsync", "Build the Navmesh Asyncronously." },
{ "NavMeshBuilder.Cancel", "Cancel Navmesh construction." },
{ "NavMeshBuilder.ClearAllNavMeshes", "Clear all Navmeshes." },
{ "NavMeshHit", "Result information for NavMesh queries." },
{ "NavMeshHit-distance", "Distance to the point of hit." },
{ "NavMeshHit-hit", "Flag set when hit." },
{ "NavMeshHit-mask", "Mask specifying NavMeshLayers at point of hit." },
{ "NavMeshHit-normal", "Normal at the point of hit." },
{ "NavMeshHit-position", "Position of hit." },
{ "NavMeshObstacle", "An obstacle for NavMeshAgents to avoid." },
{ "NavMeshObstacle-carving", "Should this obstacle make a cut-out in the navmesh." },
{ "NavMeshObstacle-carvingMoveThreshold", "Threshold distance for updating a moving carved hole (when carving is enabled)." },
{ "NavMeshObstacle-height", "Height of the obstacle's cylinder shape." },
{ "NavMeshObstacle-radius", "Radius of the obstacle's cylinder shape." },
{ "NavMeshObstacle-velocity", "Velocity at which the obstacle moves around the NavMesh." },
{ "NavMeshPath", "A path as calculated by the navigation system." },
{ "NavMeshPath-corners", "Corner points of the path. (Read Only)" },
{ "NavMeshPath-ctor", "NavMeshPath constructor." },
{ "NavMeshPath-status", "Status of the path. (Read Only)" },
{ "NavMeshPath.ClearCorners", "Erase all corner points from path." },
{ "NavMeshPathStatus", "Status of path." },
{ "NavMeshPathStatus.PathComplete", "The path terminates at the destination." },
{ "NavMeshPathStatus.PathInvalid", "The path is invalid." },
{ "NavMeshPathStatus.PathPartial", "The path cannot reach the destination." },
{ "NavMeshTriangulation", "Contains data describing a triangulation of a navmesh." },
{ "NavMeshTriangulation-indices", "Triangle indices for the navmesh triangulation." },
{ "NavMeshTriangulation-layers", "NavMeshLayer values for the navmesh triangulation." },
{ "NavMeshTriangulation-vertices", "Vertices for the navmesh triangulation." },
{ "Network", "The network class is at the heart of the network implementation and provides the core functions." },
{ "Network-connections", "All connected players." },
{ "Network-connectionTesterIP", "The IP address of the connection tester used in Network.TestConnection." },
{ "Network-connectionTesterPort", "The port of the connection tester used in Network.TestConnection." },
{ "Network-incomingPassword", "Set the password for the server (for incoming connections)." },
{ "Network-isClient", "Returns true if your peer type is client." },
{ "Network-isMessageQueueRunning", "Enable or disable the processing of network messages." },
{ "Network-isServer", "Returns true if your peer type is server." },
{ "Network-logLevel", "Set the log level for network messages (default is Off)." },
{ "Network-maxConnections", "Set the maximum amount of connections/players allowed." },
{ "Network-minimumAllocatableViewIDs", "Get or set the minimum number of ViewID numbers in the ViewID pool given to clients by the server." },
{ "Network-natFacilitatorIP", "The IP address of the NAT punchthrough facilitator." },
{ "Network-natFacilitatorPort", "The port of the NAT punchthrough facilitator." },
{ "Network-peerType", "The status of the peer type, i.e. if it is disconnected, connecting, server or client." },
{ "Network-player", "Get the local NetworkPlayer instance." },
{ "Network-proxyIP", "The IP address of the proxy server." },
{ "Network-proxyPassword", "Set the proxy server password." },
{ "Network-proxyPort", "The port of the proxy server." },
{ "Network-sendRate", "The default send rate of network updates for all Network Views." },
{ "Network-time", "Get the current network time (seconds)." },
{ "Network-useProxy", "Indicate if proxy support is needed, in which case traffic is relayed through the proxy server." },
{ "Network.AllocateViewID", "Query for the next available network view ID number and allocate it (reserve)." },
{ "Network.CloseConnection", "Close the connection to another system." },
{ "Network.Connect", "Connect to the specified host (ip or domain name) and server port." },
{ "Network.Destroy", "Destroy the object associated with this view ID across the network." },
{ "Network.DestroyPlayerObjects", "Destroy all the objects based on view IDs belonging to this player." },
{ "Network.Disconnect", "Close all open connections and shuts down the network interface." },
{ "Network.GetAveragePing", "The last average ping time to the given player in milliseconds." },
{ "Network.GetLastPing", "The last ping time to the given player in milliseconds." },
{ "Network.HavePublicAddress", "Check if this machine has a public IP address." },
{ "Network.InitializeSecurity", "Initializes security layer." },
{ "Network.InitializeServer", "Initialize the server." },
{ "Network.Instantiate", "Network instantiate a prefab." },
{ "Network.OnConnectedToServer", "Called on the client when you have successfully connected to a server." },
{ "Network.OnDisconnectedFromServer", "Called on client during disconnection from server, but also on the server when the connection has disconnected." },
{ "Network.OnFailedToConnect", "Called on the client when a connection attempt fails for some reason." },
{ "Network.OnNetworkInstantiate", "Called on objects which have been network instantiated with Network.Instantiate." },
{ "Network.OnPlayerConnected", "Called on the server whenever a new player has successfully connected." },
{ "Network.OnPlayerDisconnected", "Called on the server whenever a player is disconnected from the server." },
{ "Network.OnSerializeNetworkView", "Used to customize synchronization of variables in a script watched by a network view." },
{ "Network.OnServerInitialized", "Called on the server whenever a Network.InitializeServer was invoked and has completed." },
{ "Network.RemoveRPCs", "Remove all RPC functions which belong to this player ID." },
{ "Network.RemoveRPCsInGroup", "Remove all RPC functions which belong to given group number." },
{ "Network.SetLevelPrefix", "Set the level prefix which will then be prefixed to all network ViewID numbers." },
{ "Network.SetReceivingEnabled", "Enable or disables the reception of messages in a specific group number from a specific player." },
{ "Network.SetSendingEnabled", "Enables or disables transmission of messages and RPC calls on a specific network group number." },
{ "Network.TestConnection", "Test this machines network connection." },
{ "Network.TestConnectionNAT", "Test the connecction specifically for NAT punchthrough connectivity." },
{ "NetworkConnectionError", "Possible status messages returned by Network.Connect and in OnFailedToConnect in case the error was not immediate." },
{ "NetworkConnectionError.AlreadyConnectedToAnotherServer", "Cannot connect to two servers at once. Close the connection before connecting again." },
{ "NetworkConnectionError.AlreadyConnectedToServer", "We are already connected to this particular server (can happen after fast disconnect/reconnect)." },
{ "NetworkConnectionError.ConnectionBanned", "We are banned from the system we attempted to connect to (likely temporarily)." },
{ "NetworkConnectionError.ConnectionFailed", "Connection attempt failed, possibly because of internal connectivity problems." },
{ "NetworkConnectionError.CreateSocketOrThreadFailure", "Internal error while attempting to initialize network interface. Socket possibly already in use." },
{ "NetworkConnectionError.EmptyConnectTarget", "No host target given in Connect." },
{ "NetworkConnectionError.IncorrectParameters", "Incorrect parameters given to Connect function." },
{ "NetworkConnectionError.InternalDirectConnectFailed", "Client could not connect internally to same network NAT enabled server." },
{ "NetworkConnectionError.InvalidPassword", "The server is using a password and has refused our connection because we did not set the correct password." },
{ "NetworkConnectionError.NATPunchthroughFailed", "NAT punchthrough attempt has failed. The cause could be a too restrictive NAT implementation on either endpoints." },
{ "NetworkConnectionError.NATTargetConnectionLost", "Connection lost while attempting to connect to NAT target." },
{ "NetworkConnectionError.NATTargetNotConnected", "The NAT target we are trying to connect to is not connected to the facilitator server." },
{ "NetworkConnectionError.NoError", "No error occurred." },
{ "NetworkConnectionError.RSAPublicKeyMismatch", "We presented an RSA public key which does not match what the system we connected to is using." },
{ "NetworkConnectionError.TooManyConnectedPlayers", "The server is at full capacity, failed to connect." },
{ "NetworkDisconnection", "The reason a disconnect event occured, like in OnDisconnectedFromServer." },
{ "NetworkDisconnection.Disconnected", "The connection to the system has been closed." },
{ "NetworkDisconnection.LostConnection", "The connection to the system has been lost, no reliable packets could be delivered." },
{ "NetworkLogLevel", "Describes different levels of log information the network layer supports." },
{ "NetworkLogLevel.Full", "Full debug level logging down to each individual message being reported." },
{ "NetworkLogLevel.Informational", "Report informational messages like connectivity events." },
{ "NetworkLogLevel.Off", "Only report errors, otherwise silent." },
{ "NetworkMessageInfo", "This data structure contains information on a message just received from the network." },
{ "NetworkMessageInfo-networkView", "The NetworkView who sent this message." },
{ "NetworkMessageInfo-sender", "The player who sent this network message (owner)." },
{ "NetworkMessageInfo-timestamp", "The time stamp when the Message was sent in seconds." },
{ "NetworkPeerType", "Describes the status of the network interface peer type as returned by Network.peerType." },
{ "NetworkPeerType.Client", "Running as client." },
{ "NetworkPeerType.Connecting", "Attempting to connect to a server." },
{ "NetworkPeerType.Disconnected", "No client connection running. Server not initialized." },
{ "NetworkPeerType.Server", "Running as server." },
{ "NetworkPlayer", "The NetworkPlayer is a data structure with which you can locate another player over the network." },
{ "NetworkPlayer-externalIP", "Returns the external IP address of the network interface." },
{ "NetworkPlayer-externalPort", "Returns the external port of the network interface." },
{ "NetworkPlayer-guid", "The GUID for this player, used when connecting with NAT punchthrough." },
{ "NetworkPlayer-ipAddress", "The IP address of this player." },
{ "NetworkPlayer-operator_eq", "Returns true if two NetworkPlayers are the same player." },
{ "NetworkPlayer-operator_ne", "Returns true if two NetworkPlayers are not the same player." },
{ "NetworkPlayer-port", "The port of this player." },
{ "NetworkPlayer.ToString", "Returns the index number for this network player." },
{ "NetworkReachability", "Describes network reachability options." },
{ "NetworkReachability.NotReachable", "Network is not reachable." },
{ "NetworkReachability.ReachableViaCarrierDataNetwork", "Network is reachable via carrier data network." },
{ "NetworkReachability.ReachableViaLocalAreaNetwork", "Network is reachable via WiFi or cable." },
{ "NetworkStateSynchronization", "Different types of synchronization for the NetworkView component." },
{ "NetworkStateSynchronization.Off", "No state data will be synchronized." },
{ "NetworkStateSynchronization.ReliableDeltaCompressed", "All packets are sent reliable and ordered." },
{ "NetworkStateSynchronization.Unreliable", "Brute force unreliable state sending." },
{ "NetworkView", "The network view is the binding material of multiplayer games." },
{ "NetworkView-group", "The network group number of this network view." },
{ "NetworkView-isMine", "Is the network view controlled by this object?" },
{ "NetworkView-observed", "The component the network view is observing." },
{ "NetworkView-owner", "The NetworkPlayer who owns this network view." },
{ "NetworkView-stateSynchronization", "The type of NetworkStateSynchronization set for this network view." },
{ "NetworkView-viewID", "The ViewID of this network view." },
{ "NetworkView.Find", "Find a network view based on a NetworkViewID." },
{ "NetworkView.RPC", "Call a RPC function on all connected peers." },
{ "NetworkView.SetScope", "Set the scope of the network view in relation to a specific network player." },
{ "NetworkViewID", "The NetworkViewID is a unique identifier for a network view instance in a multiplayer game." },
{ "NetworkViewID-isMine", "True if instantiated by me." },
{ "NetworkViewID-operator_eq", "Returns true if two NetworkViewIDs are identical." },
{ "NetworkViewID-operator_ne", "Returns true if two NetworkViewIDs are not identical." },
{ "NetworkViewID-owner", "The NetworkPlayer who owns the NetworkView. Could be the server." },
{ "NetworkViewID-unassigned", "Represents an invalid network view ID." },
{ "NetworkViewID.ToString", "Returns a formatted string with details on this NetworkViewID." },
{ "NonSerializable", "The NonSerialized attribute marks a variable to not be serialized." },
{ "NotConvertedAttribute", "Instructs the build pipeline not to convert a type or member to the target platform." },
{ "NotFlashValidatedAttribute", "Instructs the build pipeline not to try and validate a type or member for the flash platform." },
{ "NotificationServices", "NotificationServices is only available on iPhone/iPad/iPod Touch." },
{ "NotificationServices-deviceToken", "Device token received from Apple Push Service after calling NotificationServices.RegisterForRemoteNotificationTypes. (Read Only)" },
{ "NotificationServices-enabledRemoteNotificationTypes", "The types of notifications the application accepts." },
{ "NotificationServices-localNotificationCount", "The number of received local notifications. (Read Only)" },
{ "NotificationServices-localNotifications", "The list of objects representing received local notifications. (Read Only)" },
{ "NotificationServices-registrationError", "Returns an error that might occur on registration for remote notifications via NotificationServices.RegisterForRemoteNotificationTypes. (Read Only)" },
{ "NotificationServices-remoteNotificationCount", "The number of received remote notifications. (Read Only)" },
{ "NotificationServices-remoteNotifications", "The list of objects representing received remote notifications. (Read Only)" },
{ "NotificationServices-scheduledLocalNotifications", "All currently scheduled local notifications." },
{ "NotificationServices.CancelAllLocalNotifications", "Cancels the delivery of all scheduled local notifications." },
{ "NotificationServices.CancelLocalNotification", "Cancels the delivery of the specified scheduled local notification." },
{ "NotificationServices.ClearLocalNotifications", "Discards of all received local notifications." },
{ "NotificationServices.ClearRemoteNotifications", "Discards of all received remote notifications." },
{ "NotificationServices.GetLocalNotification", "Returns an object representing a specific local notification. (Read Only)" },
{ "NotificationServices.GetRemoteNotification", "Returns an object representing a specific remote notification. (Read Only)" },
{ "NotificationServices.PresentLocalNotificationNow", "Presents a local notification immediately." },
{ "NotificationServices.RegisterForRemoteNotificationTypes", "Register to receive remote notifications of the specified types from a provider via Apple Push Service." },
{ "NotificationServices.ScheduleLocalNotification", "Schedules a local notification." },
{ "NotificationServices.UnregisterForRemoteNotifications", "Unregister for remote notifications." },
{ "NotRenamedAttribute", "Prevent name mangling of constructors, methods, fields and properties." },
{ "NPOTSupport", "NPOT textures support." },
{ "NPOTSupport.Full", "Full NPOT support." },
{ "NPOTSupport.None", "NPOT textures are not supported. Will be upscaled/padded at loading time." },
{ "NPOTSupport.Restricted", "Limited NPOT support: no mip-maps and clamp wrap mode will be forced." },
{ "Object", "Base class for all objects Unity can reference." },
{ "Object-hideFlags", "Should the object be hidden, saved with the scene or modifiable by the user?" },
{ "Object-name", "The name of the object." },
{ "Object-operator_eq", "Compares if two objects refer to the same." },
{ "Object-operator_ne", "Compares if two objects refer to a different object." },
{ "Object-operator_Object", "Does the object exist?" },
{ "Object.Destroy", "Removes a gameobject, component or asset." },
{ "Object.DestroyImmediate", "Destroys the object obj immediately. You are strongly recommended to use Destroy instead." },
{ "Object.DontDestroyOnLoad", "Makes the object target not be destroyed automatically when loading a new scene." },
{ "Object.FindObjectOfType", "Returns the first active loaded object of Type type." },
{ "Object.FindObjectsOfType", "Returns a list of all active loaded objects of Type type." },
{ "Object.GetInstanceID", "Returns the instance id of the object." },
{ "Object.Instantiate", "Clones the object original and returns the clone." },
{ "Object.ToString", "Returns the name of the game object." },
{ "ObjectNames", "Helper class for constructing displayable names for objects." },
{ "ObjectNames.GetClassName", "Class name of an object." },
{ "ObjectNames.GetDragAndDropTitle", "Drag and drop title for an object." },
{ "ObjectNames.GetInspectorTitle", "Inspector title for an object." },
{ "ObjectNames.NicifyVariableName", "Make a displayable name for a variable." },
{ "ObjectNames.SetNameSmart", "Sets the name of an Object." },
{ "ObjectPreview", "Base Class to derive from when creating Custom Previews." },
{ "ObjectPreview-target", "The object currently being previewed." },
{ "ObjectPreview.DrawPreview", "This is the first entry point for Preview Drawing." },
{ "ObjectPreview.GetInfoString", "Implement this method to show object information on top of the object preview." },
{ "ObjectPreview.GetPreviewTitle", "Override this method if you want to change the label of the Preview area." },
{ "ObjectPreview.HasPreviewGUI", "Wheather the current target can be previwed." },
{ "ObjectPreview.Initialize", "Called when the Preview get's created with the objects being previwed." },
{ "ObjectPreview.MoveNextTarget", "Called to iterate through the targets, this will be used when previewing more than one target." },
{ "ObjectPreview.OnInteractivePreviewGUI", "Implement to create your own interactive custom preview. Interactive custom previews are used in the preview area of the inspector and the object selector." },
{ "ObjectPreview.OnPreviewGUI", "Implement to create your own custom preview for the preview area of the inspector, primary editor headers and the object selector." },
{ "ObjectPreview.OnPreviewSettings", "Override this method if you want to show custom controls in the preview header." },
{ "ObjectPreview.ResetTarget", "Called to Reset the target before iterating through them." },
{ "ObstacleAvoidanceType", "Level of obstacle avoidance." },
{ "ObstacleAvoidanceType.GoodQualityObstacleAvoidance", "Good avoidance. High performance impact." },
{ "ObstacleAvoidanceType.HighQualityObstacleAvoidance", "Enable highest precision. Highest performance impact." },
{ "ObstacleAvoidanceType.LowQualityObstacleAvoidance", "Enable simple avoidance. Low performance impact." },
{ "ObstacleAvoidanceType.MedQualityObstacleAvoidance", "Medium avoidance. Medium performance impact." },
{ "ObstacleAvoidanceType.NoObstacleAvoidance", "Disable avoidance." },
{ "OcclusionArea", "OcclusionArea is an area in which occlusion culling is performed." },
{ "OcclusionArea-center", "Center of the occlusion area relative to the transform." },
{ "OcclusionArea-size", "Size that the occlusion area will have." },
{ "OcclusionPortal", "The portal for dynamically changing occlusion at runtime." },
{ "OcclusionPortal-open", "Gets / sets the portal's open state." },
{ "OffMeshLink", "Link allowing movement outside the planar navigation mesh." },
{ "OffMeshLink-activated", "Is link active." },
{ "OffMeshLink-autoUpdatePositions", "Automatically update endpoints." },
{ "OffMeshLink-biDirectional", "Can link be traversed in both directions." },
{ "OffMeshLink-costOverride", "Modify pathfinding cost for the link." },
{ "OffMeshLink-endTransform", "The transform representing link end position." },
{ "OffMeshLink-navMeshLayer", "NavMeshLayer for this OffMeshLink component." },
{ "OffMeshLink-occupied", "Is link occupied. (Read Only)" },
{ "OffMeshLink-startTransform", "The transform representing link start position." },
{ "OffMeshLink.UpdatePositions", "Explicitly update the link endpoints." },
{ "OffMeshLinkData", "State of OffMeshLink." },
{ "OffMeshLinkData-activated", "Is link active (Read Only)." },
{ "OffMeshLinkData-endPos", "Link end world position (Read Only)." },
{ "OffMeshLinkData-linkType", "Link type specifier (Read Only)." },
{ "OffMeshLinkData-offMeshLink", "The OffMeshLink if the link type is a manually placed Offmeshlink (Read Only)." },
{ "OffMeshLinkData-startPos", "Link start world position (Read Only)." },
{ "OffMeshLinkData-valid", "Is link valid (Read Only)." },
{ "OffMeshLinkType", "Link type specifier." },
{ "OffMeshLinkType.LinkTypeDropDown", "Vertical drop." },
{ "OffMeshLinkType.LinkTypeJumpAcross", "Horizontal jump." },
{ "OffMeshLinkType.LinkTypeManual", "Manually specified type of link." },
{ "Particle", "(Legacy Particle system)." },
{ "Particle-angularVelocity", "The angular velocity of the particle." },
{ "Particle-color", "The color of the particle." },
{ "Particle-energy", "The energy of the particle." },
{ "Particle-position", "The position of the particle." },
{ "Particle-rotation", "The rotation of the particle." },
{ "Particle-size", "The size of the particle." },
{ "Particle-startEnergy", "The starting energy of the particle." },
{ "Particle-velocity", "The velocity of the particle." },
{ "ParticleAnimator", "(Legacy Particles) Particle animators move your particles over time, you use them to apply wind, drag & color cycling to your particle emitters." },
{ "ParticleAnimator-autodestruct", "Does the GameObject of this particle animator auto destructs?" },
{ "ParticleAnimator-colorAnimation", "Colors the particles will cycle through over their lifetime." },
{ "ParticleAnimator-damping", "How much particles are slowed down every frame." },
{ "ParticleAnimator-doesAnimateColor", "Do particles cycle their color over their lifetime?" },
{ "ParticleAnimator-force", "The force being applied to particles every frame." },
{ "ParticleAnimator-localRotationAxis", "Local space axis the particles rotate around." },
{ "ParticleAnimator-rndForce", "A random force added to particles every frame." },
{ "ParticleAnimator-sizeGrow", "How the particle sizes grow over their lifetime." },
{ "ParticleAnimator-worldRotationAxis", "World space axis the particles rotate around." },
{ "ParticleEmitter", "(Legacy Particles) Script interface for particle emitters." },
{ "ParticleEmitter-angularVelocity", "The angular velocity of new particles in degrees per second." },
{ "ParticleEmitter-emit", "Should particles be automatically emitted each frame?" },
{ "ParticleEmitter-emitterVelocityScale", "The amount of the emitter's speed that the particles inherit." },
{ "ParticleEmitter-enabled", "Turns the ParticleEmitter on or off." },
{ "ParticleEmitter-localVelocity", "The starting speed of particles along X, Y, and Z, measured in the object's orientation." },
{ "ParticleEmitter-maxEmission", "The maximum number of particles that will be spawned every second." },
{ "ParticleEmitter-maxEnergy", "The maximum lifetime of each particle, measured in seconds." },
{ "ParticleEmitter-maxSize", "The maximum size each particle can be at the time when it is spawned." },
{ "ParticleEmitter-minEmission", "The minimum number of particles that will be spawned every second." },
{ "ParticleEmitter-minEnergy", "The minimum lifetime of each particle, measured in seconds." },
{ "ParticleEmitter-minSize", "The minimum size each particle can be at the time when it is spawned." },
{ "ParticleEmitter-particleCount", "The current number of particles (Read Only)." },
{ "ParticleEmitter-particles", "Returns a copy of all particles and assigns an array of all particles to be the current particles." },
{ "ParticleEmitter-rndAngularVelocity", "A random angular velocity modifier for new particles." },
{ "ParticleEmitter-rndRotation", "If enabled, the particles will be spawned with random rotations." },
{ "ParticleEmitter-rndVelocity", "A random speed along X, Y, and Z that is added to the velocity." },
{ "ParticleEmitter-useWorldSpace", "If enabled, the particles don't move when the emitter moves. If false, when you move the emitter, the particles follow it around." },
{ "ParticleEmitter-worldVelocity", "The starting speed of particles in world space, along X, Y, and Z." },
{ "ParticleEmitter.ClearParticles", "Removes all particles from the particle emitter." },
{ "ParticleEmitter.Emit", "Emit a number of particles." },
{ "ParticleEmitter.Simulate", "Advance particle simulation by given time." },
{ "ParticleRenderer", "(Legacy Particles) Renders particles on to the screen." },
{ "ParticleRenderer-cameraVelocityScale", "How much are the particles strected depending on the Camera's speed." },
{ "ParticleRenderer-lengthScale", "How much are the particles stretched in their direction of motion." },
{ "ParticleRenderer-maxParticleSize", "Clamp the maximum particle size." },
{ "ParticleRenderer-particleRenderMode", "How particles are drawn." },
{ "ParticleRenderer-uvAnimationCycles", "Set uv animation cycles." },
{ "ParticleRenderer-uvAnimationXTile", "Set horizontal tiling count." },
{ "ParticleRenderer-uvAnimationYTile", "Set vertical tiling count." },
{ "ParticleRenderer-velocityScale", "How much are the particles strectched depending on \"how fast they move\"." },
{ "ParticleRenderMode", "The rendering mode for legacy particles." },
{ "ParticleRenderMode.Billboard", "Render the particles as billboards facing the player. (Default)" },
{ "ParticleRenderMode.HorizontalBillboard", "Render the particles as billboards always facing up along the y-Axis." },
{ "ParticleRenderMode.SortedBillboard", "Sort the particles back-to-front and render as billboards." },
{ "ParticleRenderMode.Stretch", "Stretch particles in the direction of motion." },
{ "ParticleRenderMode.VerticalBillboard", "Render the particles as billboards always facing the player, but not pitching along the x-Axis." },
{ "ParticleSystem", "Script interface for particle systems (Shuriken)." },
{ "ParticleSystem-duration", "The duration of the particle system in seconds (Read Only)." },
{ "ParticleSystem-emissionRate", "The rate of emission." },
{ "ParticleSystem-enableEmission", "When set to false, the particle system will not emit particles." },
{ "ParticleSystem-gravityModifier", "Scale being applied to the gravity defined by Physics.gravity." },
{ "ParticleSystem-isPaused", "Is the particle system paused right now ?" },
{ "ParticleSystem-isPlaying", "Is the particle system playing right now ?" },
{ "ParticleSystem-isStopped", "Is the particle system stopped right now ?" },
{ "ParticleSystem-loop", "Is the particle system looping?" },
{ "ParticleSystem-maxParticles", "The maximum number of particles to emit." },
{ "ParticleSystem-particleCount", "The current number of particles (Read Only)." },
{ "ParticleSystem-playbackSpeed", "The playback speed of the particle system. 1 is normal playback speed." },
{ "ParticleSystem-playOnAwake", "If set to true, the particle system will automatically start playing on startup." },
{ "ParticleSystem-randomSeed", "Random seed used for the particle system emission. If set to 0, it will be assigned a random value on awake." },
{ "ParticleSystem-safeCollisionEventSize", "Safe array size for use with ParticleSystem.GetCollisionEvents." },
{ "ParticleSystem-simulationSpace", "This selects the space in which to simulate particles. It can be either world or local space." },
{ "ParticleSystem-startColor", "The initial color of particles when emitted." },
{ "ParticleSystem-startDelay", "Start delay in seconds." },
{ "ParticleSystem-startLifetime", "The total lifetime in seconds that particles will have when emitted. When using curves, this values acts as a scale on the curve. This value is set in the particle when it is create by the particle system." },
{ "ParticleSystem-startRotation", "The initial rotation of particles when emitted. When using curves, this values acts as a scale on the curve." },
{ "ParticleSystem-startSize", "The initial size of particles when emitted. When using curves, this values acts as a scale on the curve." },
{ "ParticleSystem-startSpeed", "The initial speed of particles when emitted. When using curves, this values acts as a scale on the curve." },
{ "ParticleSystem-time", "Playback position in seconds." },
{ "ParticleSystem.Clear", "Remove all particles in the particle system." },
{ "ParticleSystem.CollisionEvent", "Information about a particle collision." },
{ "ParticleSystem.CollisionEvent-collider", "The Collider for the GameObject struck by the particles." },
{ "ParticleSystem.CollisionEvent-intersection", "Intersection point of the collision in world coordinates." },
{ "ParticleSystem.CollisionEvent-normal", "Geometry normal at the intersection point of the collision." },
{ "ParticleSystem.CollisionEvent-velocity", "Incident velocity at the intersection point of the collision." },
{ "ParticleSystem.Emit", "Emit count particles immediately." },
{ "ParticleSystem.GetCollisionEvents", "Get the particle collision events for a GameObject. Returns the number of events written to the array." },
{ "ParticleSystem.GetParticles", "Get the particles of this particle system. Returns the number of particles written to the input particle array." },
{ "ParticleSystem.IsAlive", "Does the system have any live particles (or will produce more)?" },
{ "ParticleSystem.Particle", "Script interface for a Particle." },
{ "ParticleSystem.Particle-angularVelocity", "The angular velocity of the particle." },
{ "ParticleSystem.Particle-color", "The initial color of the particle. The current color of the particle is calculated procedurally based on this value and the active color modules." },
{ "ParticleSystem.Particle-lifetime", "The lifetime of the particle." },
{ "ParticleSystem.Particle-position", "The position of the particle." },
{ "ParticleSystem.Particle-randomSeed", "The random seed of the particle." },
{ "ParticleSystem.Particle-rotation", "The rotation of the particle." },
{ "ParticleSystem.Particle-size", "The initial size of the particle. The current size of the particle is calculated procedurally based on this value and the active size modules." },
{ "ParticleSystem.Particle-startLifetime", "The starting lifetime of the particle." },
{ "ParticleSystem.Particle-velocity", "The velocity of the particle." },
{ "ParticleSystem.Pause", "Pauses playing the particle system." },
{ "ParticleSystem.Play", "Plays the particle system." },
{ "ParticleSystem.SetParticles", "Set the particles of this particle system. size is the number of particles that is set." },
{ "ParticleSystem.Simulate", "Fastforwards the particle system by simulating particles over given period of time, then pauses it." },
{ "ParticleSystem.Stop", "Stops playing the particle system." },
{ "ParticleSystemRenderer", "Renders particles on to the screen (Shuriken)." },
{ "ParticleSystemRenderer-cameraVelocityScale", "How much are the particles strected depending on the Camera's speed." },
{ "ParticleSystemRenderer-lengthScale", "How much are the particles stretched in their direction of motion." },
{ "ParticleSystemRenderer-maxParticleSize", "Clamp the maximum particle size." },
{ "ParticleSystemRenderer-mesh", "Mesh used as particle instead of billboarded texture." },
{ "ParticleSystemRenderer-renderMode", "How particles are drawn." },
{ "ParticleSystemRenderer-velocityScale", "How much are the particles strectched depending on \"how fast they move\"." },
{ "ParticleSystemRenderMode", "The rendering mode for particle systems (Shuriken)." },
{ "ParticleSystemRenderMode.Billboard", "Render particles as billboards facing the player. (Default)" },
{ "ParticleSystemRenderMode.HorizontalBillboard", "Render particles as billboards always facing up along the y-Axis." },
{ "ParticleSystemRenderMode.Mesh", "Render particles as meshes." },
{ "ParticleSystemRenderMode.Stretch", "Stretch particles in the direction of motion." },
{ "ParticleSystemRenderMode.VerticalBillboard", "Render particles as billboards always facing the player, but not pitching along the x-Axis." },
{ "ParticleSystemSimulationSpace", "The space to simulate particles in." },
{ "ParticleSystemSimulationSpace.Local", "Simulate particles in local space." },
{ "ParticleSystemSimulationSpace.World", "Simulate particles in world space." },
{ "Path", "Performs operations on strings that contain file or directory path information." },
{ "Path.AltDirectorySeparatorChar", "An alternate character used to separate directory levels. (Read Only)" },
{ "Path.Combine", "Concatenates two path strings." },
{ "Path.DirectorySeparatorChar", "The default character used to separate directory levels. (Read Only)" },
{ "Path.GetDirectoryName", "Returns the directory name component of the specified path string." },
{ "Path.GetExtension", "Returns the extension component of the specified path string." },
{ "Path.GetFileName", "Returns the file name, including the extension if any, of the specified path string." },
{ "Path.GetFileNameWithoutExtension", "Returns the file base component of the specified path string without the extension." },
{ "PhysicMaterial", "Physics material describes how to handle colliding objects (friction, bounciness)." },
{ "PhysicMaterial-bounceCombine", "Determines how the bounciness is combined." },
{ "PhysicMaterial-bounciness", "How bouncy is the surface? A value of 0 will not bounce. A value of 1 will bounce without any loss of energy." },
{ "PhysicMaterial-ctor", "Creates a new material." },
{ "PhysicMaterial-dynamicFriction", "The friction used when already moving. This value has to be between 0 and 1." },
{ "PhysicMaterial-dynamicFriction2", "If anisotropic friction is enabled, dynamicFriction2 will be applied along frictionDirection2." },
{ "PhysicMaterial-frictionCombine", "Determines how the friction is combined." },
{ "PhysicMaterial-frictionDirection2", "The direction of anisotropy. Anisotropic friction is enabled if the vector is not zero." },
{ "PhysicMaterial-staticFriction", "The friction coefficient used when an object is lying on a surface." },
{ "PhysicMaterial-staticFriction2", "If anisotropic friction is enabled, staticFriction2 will be applied along frictionDirection2." },
{ "PhysicMaterialCombine", "Describes how physic materials of colliding objects are combined." },
{ "PhysicMaterialCombine.Average", "Averages the friction/bounce of the two colliding materials." },
{ "PhysicMaterialCombine.Maximum", "Uses the larger friction/bounce of the two colliding materials." },
{ "PhysicMaterialCombine.Minimum", "Uses the smaller friction/bounce of the two colliding materials." },
{ "PhysicMaterialCombine.Multiply", "Multiplies the friction/bounce of the two colliding materials." },
{ "Physics", "Global physics properties and helper methods." },
{ "Physics-bounceThreshold", "Two colliding objects with a relative velocity below this will not bounce (default 2). Must be positive." },
{ "Physics-gravity", "The gravity applied to all rigid bodies in the scene." },
{ "Physics-maxAngularVelocity", "The default maximum angular velocity permitted for any rigid bodies (default 7). Must be positive." },
{ "Physics-minPenetrationForPenalty", "The minimum contact penetration value in order to apply a penalty force (default 0.05). Must be positive." },
{ "Physics-sleepAngularVelocity", "The default angular velocity, below which objects start sleeping (default 0.14). Must be positive." },
{ "Physics-sleepVelocity", "The default linear velocity, below which objects start going to sleep (default 0.15). Must be positive." },
{ "Physics-solverIterationCount", "The default solver iteration count permitted for any rigid bodies (default 7). Must be positive." },
{ "Physics.AllLayers", "Layer mask constant to select all layers." },
{ "Physics.CapsuleCast", "Casts a capsule against all colliders in the scene and returns detailed information on what was hit." },
{ "Physics.CapsuleCastAll", "Like Physics.CapsuleCast, but this function will return all hits the capsule sweep intersects." },
{ "Physics.CheckCapsule", "Returns true if there are any colliders overlapping the capsule defined by the axis going from start and end and having radius in world coordinates." },
{ "Physics.CheckSphere", "Returns true if there are any colliders overlapping the sphere defined by position and radius in world coordinates." },
{ "Physics.DefaultRaycastLayers", "Layer mask constant to select default raycast layers." },
{ "Physics.GetIgnoreLayerCollision", "Are collisions between layer1 and layer2 being ignored?" },
{ "Physics.IgnoreCollision", "Makes the collision detection system ignore all collisions between collider1 and collider2." },
{ "Physics.IgnoreLayerCollision", "Makes the collision detection system ignore all collisions between any collider in layer1 and any collider in layer2." },
{ "Physics.IgnoreRaycastLayer", "Layer mask constant to select ignore raycast layer." },
{ "Physics.Linecast", "Returns true if there is any collider intersecting the line between start and end." },
{ "Physics.OverlapSphere", "Returns an array with all colliders touching or inside the sphere." },
{ "Physics.Raycast", "Casts a ray against all colliders in the scene." },
{ "Physics.RaycastAll", "Casts a ray through the scene and returns all hits. Note that order is not guaranteed." },
{ "Physics.SphereCast", "Casts a sphere against all colliders in the scene and returns detailed information on what was hit." },
{ "Physics.SphereCastAll", "Like Physics.SphereCast, but this function will return all hits the sphere sweep intersects." },
{ "Physics2D", "Global settings and helpers for 2D physics." },
{ "Physics2D-angularSleepTolerance", "A rigid-body cannot sleep if its angular velocity is above this tolerance." },
{ "Physics2D-baumgarteScale", "The scale factor that controls how fast overlaps are resolved." },
{ "Physics2D-baumgarteTOIScale", "The scale factor that controls how fast TOI overlaps are resolved." },
{ "Physics2D-gravity", "Acceleration due to gravity." },
{ "Physics2D-linearSleepTolerance", "A rigid-body cannot sleep if its linear velocity is above this tolerance." },
{ "Physics2D-maxAngularCorrection", "The maximum angular position correction used when solving constraints. This helps to prevent overshoot." },
{ "Physics2D-maxLinearCorrection", "The maximum linear position correction used when solving constraints. This helps to prevent overshoot." },
{ "Physics2D-maxRotationSpeed", "The maximum angular speed of a rigid-body per physics update. Increasing this can cause numerical problems." },
{ "Physics2D-maxTranslationSpeed", "The maximum linear speed of a rigid-body per physics update. Increasing this can cause numerical problems." },
{ "Physics2D-positionIterations", "The number of iterations of the physics solver when considering objects' positions." },
{ "Physics2D-raycastsHitTriggers", "Do raycasts detect Colliders configured as triggers?" },
{ "Physics2D-timeToSleep", "The time in seconds that a rigid-body must be still before it will go to sleep." },
{ "Physics2D-velocityIterations", "The number of iterations of the physics solver when considering objects' velocities." },
{ "Physics2D-velocityThreshold", "Any collisions with a relative linear velocity below this threshold will be treated as inelastic." },
{ "Physics2D.AllLayers", "Layer mask constant that includes all layers." },
{ "Physics2D.BoxCast", "Casts a box against colliders in the scene, returning the first collider to contact with it." },
{ "Physics2D.BoxCastAll", "Casts a box against colliders in the scene, returning all colliders that contact with it." },
{ "Physics2D.BoxCastNonAlloc", "Casts a box into the scene, returning colliders that contact with it into the provided results array." },
{ "Physics2D.CircleCast", "Casts a circle against colliders in the scene, returning the first collider to contact with it." },
{ "Physics2D.CircleCastAll", "Casts a circle against colliders in the scene, returning all colliders that contact with it." },
{ "Physics2D.CircleCastNonAlloc", "Casts a circle into the scene, returning colliders that contact with it into the provided results array." },
{ "Physics2D.DefaultRaycastLayers", "Layer mask constant that includes all layers participating in raycasts by default." },
{ "Physics2D.GetIgnoreCollision", "Checks whether the collision detection system will ignore all collisions/triggers between collider1 and collider2 or not." },
{ "Physics2D.GetIgnoreLayerCollision", "Should collisions between the specified layers be ignored?" },
{ "Physics2D.GetRayIntersection", "Cast a 3D ray against the colliders in the scene returning the first collider along the ray." },
{ "Physics2D.GetRayIntersectionAll", "Cast a 3D ray against the colliders in the scene returning all the colliders along the ray." },
{ "Physics2D.GetRayIntersectionNonAlloc", "Cast a 3D ray against the colliders in the scene returning the colliders along the ray." },
{ "Physics2D.IgnoreCollision", "Makes the collision detection system ignore all collisions/triggers between collider1 and collider2." },
{ "Physics2D.IgnoreLayerCollision", "Choose whether to detect or ignore collisions between a specified pair of layers." },
{ "Physics2D.IgnoreRaycastLayer", "Layer mask constant for the default layer that ignores raycasts." },
{ "Physics2D.Linecast", "Casts a line against colliders in the scene." },
{ "Physics2D.LinecastAll", "Casts a line against colliders in the scene." },
{ "Physics2D.LinecastNonAlloc", "Casts a line against colliders in the scene." },
{ "Physics2D.OverlapArea", "Check if a collider falls within a rectangular area." },
{ "Physics2D.OverlapAreaAll", "Get a list of all colliders that fall within a rectangular area." },
{ "Physics2D.OverlapAreaNonAlloc", "Get a list of all colliders that fall within a specified area." },
{ "Physics2D.OverlapCircle", "Check if a collider falls within a circular area." },
{ "Physics2D.OverlapCircleAll", "Get a list of all colliders that fall within a circular area." },
{ "Physics2D.OverlapCircleNonAlloc", "Get a list of all colliders that fall within a circular area." },
{ "Physics2D.OverlapPoint", "Check if a collider overlaps a point in space." },
{ "Physics2D.OverlapPointAll", "Get a list of all colliders that overlap a point in space." },
{ "Physics2D.OverlapPointNonAlloc", "Get a list of all colliders that overlap a point in space." },
{ "Physics2D.Raycast", "Casts a ray against colliders in the scene." },
{ "Physics2D.RaycastAll", "Casts a ray against colliders in the scene, returning all colliders that contact with it." },
{ "Physics2D.RaycastNonAlloc", "Casts a ray into the scene." },
{ "PhysicsMaterial2D", "Asset type that defines the surface properties of a Collider2D." },
{ "PhysicsMaterial2D-bounciness", "The degree of elasticity during collisions." },
{ "PhysicsMaterial2D-friction", "Coefficient of friction." },
{ "Ping", "Ping any given IP address (given in dot notation)." },
{ "Ping-ctor", "Perform a ping to the supplied target IP address." },
{ "Ping-ip", "The IP target of the ping." },
{ "Ping-isDone", "Has the ping function completed?" },
{ "Ping-time", "This property contains the ping time result after isDone returns true." },
{ "PivotMode", "Where is the tool handle placed." },
{ "PivotMode.Center", "The tool handle is at the graphical center of the selection." },
{ "PivotMode.Pivot", "The tool handle is on the pivot point of the active object." },
{ "PivotRotation", "How is the tool handle oriented." },
{ "PivotRotation.Global", "The tool handle is aligned along the global axes." },
{ "PivotRotation.Local", "The tool handle is oriented from the active object." },
{ "Plane", "Representation of a plane in 3D space." },
{ "Plane-ctor", "Creates a plane." },
{ "Plane-distance", "Distance from the origin to the plane." },
{ "Plane-normal", "Normal vector of the plane." },
{ "Plane.GetDistanceToPoint", "Returns a signed distance from plane to point." },
{ "Plane.GetSide", "Is a point on the positive side of the plane?" },
{ "Plane.Raycast", "Intersects a ray with the plane." },
{ "Plane.SameSide", "Are two points on the same side of the plane?" },
{ "Plane.Set3Points", "Sets a plane using three points that lie within it. The points go around clockwise as you look down on the top surface of the plane." },
{ "Plane.SetNormalAndPosition", "Sets a plane using a point that lies within it along with a normal to orient it." },
{ "PlayerPrefs", "Stores and accesses player preferences between game sessions." },
{ "PlayerPrefs.DeleteAll", "Removes all keys and values from the preferences. Use with caution." },
{ "PlayerPrefs.DeleteKey", "Removes key and its corresponding value from the preferences." },
{ "PlayerPrefs.GetFloat", "Returns the value corresponding to key in the preference file if it exists." },
{ "PlayerPrefs.GetInt", "Returns the value corresponding to key in the preference file if it exists." },
{ "PlayerPrefs.GetString", "Returns the value corresponding to key in the preference file if it exists." },
{ "PlayerPrefs.HasKey", "Returns true if key exists in the preferences." },
{ "PlayerPrefs.Save", "Writes all modified preferences to disk." },
{ "PlayerPrefs.SetFloat", "Sets the value of the preference identified by key." },
{ "PlayerPrefs.SetInt", "Sets the value of the preference identified by key." },
{ "PlayerPrefs.SetString", "Sets the value of the preference identified by key." },
{ "PlayerPrefsException", "An exception thrown by the PlayerPrefs class in a web player build." },
{ "PlayerSettings", "Player Settings is where you define various parameters for the final game that you will build in Unity. Some of these values are used in the Resolution Dialog that launches when you open a standalone game." },
{ "PlayerSettings-accelerometerFrequency", "Accelerometer update frequency." },
{ "PlayerSettings-advancedLicense", "Is the advanced version being used?" },
{ "PlayerSettings-allowedAutorotateToLandscapeLeft", "Is auto-rotation to landscape left supported?" },
{ "PlayerSettings-allowedAutorotateToLandscapeRight", "Is auto-rotation to landscape right supported?" },
{ "PlayerSettings-allowedAutorotateToPortrait", "Is auto-rotation to portrait supported?" },
{ "PlayerSettings-allowedAutorotateToPortraitUpsideDown", "Is auto-rotation to portrait upside-down supported?" },
{ "PlayerSettings-aotOptions", "Additional AOT compilation options. Shared by AOT platforms." },
{ "PlayerSettings-apiCompatibilityLevel", ".NET API compatibility level." },
{ "PlayerSettings-bundleIdentifier", "Application bundle identifier shared between iOS & Android platforms." },
{ "PlayerSettings-bundleVersion", "Application bundle version shared between iOS & Android platforms." },
{ "PlayerSettings-captureSingleScreen", "Defines if fullscreen games should darken secondary displays." },
{ "PlayerSettings-colorSpace", "Set the color space for the current project." },
{ "PlayerSettings-companyName", "The name of your company." },
{ "PlayerSettings-defaultInterfaceOrientation", "Default screen orientation for mobiles." },
{ "PlayerSettings-defaultIsFullScreen", "If enabled, the game will default to fullscreen mode." },
{ "PlayerSettings-defaultScreenHeight", "Default vertical dimension of stand-alone player window." },
{ "PlayerSettings-defaultScreenWidth", "Default horizontal dimension of stand-alone player window." },
{ "PlayerSettings-defaultWebScreenHeight", "Default vertical dimension of web player window." },
{ "PlayerSettings-defaultWebScreenWidth", "Default horizontal dimension of web player window." },
{ "PlayerSettings-displayResolutionDialog", "Defines the behaviour of the Resolution Dialog on product launch." },
{ "PlayerSettings-firstStreamedLevelWithResources", "First level to have access to all Resources.Load assets in Streamed Web Players." },
{ "PlayerSettings-forceSingleInstance", "Restrict standalone players to a single concurrent running instance." },
{ "PlayerSettings-gpuSkinning", "Enable GPU skinning on capable platforms." },
{ "PlayerSettings-iPhoneBundleIdentifier", "The bundle identifier of the iPhone application." },
{ "PlayerSettings-keyaliasPass", "Password for the key used for signing an Android application." },
{ "PlayerSettings-keystorePass", "Password used for interacting with the Android Keystore." },
{ "PlayerSettings-macFullscreenMode", "Define how to handle fullscreen mode in Mac OS X standalones." },
{ "PlayerSettings-productName", "The name of your product." },
{ "PlayerSettings-ps3BackgroundPath", "PS3 Background Image." },
{ "PlayerSettings-ps3BootCheckMaxSaveGameSizeKB", "PS3 Bootcheck maximum savegame size ( as per TRC R224 ). This should include the total estimated size for the savegames (including icon sizes)." },
{ "PlayerSettings-ps3DLCConfigPath", "PS3 DLC Config file." },
{ "PlayerSettings-ps3NpCommunicationPassphrase", "The Np Comminication passphrase to use when connecting to Playstation®Network." },
{ "PlayerSettings-ps3SaveGameSlots", "PS3 Save Game slots." },
{ "PlayerSettings-ps3SoundPath", "PS3 Background Sound." },
{ "PlayerSettings-ps3ThumbnailPath", "PS3 Thumbnail Image." },
{ "PlayerSettings-ps3TitleConfigPath", "PS3 Title Config file." },
{ "PlayerSettings-ps3TrialMode", "PS3 Title is Trial." },
{ "PlayerSettings-ps3TrophyCommId", "PS3 Trophy Communication ID." },
{ "PlayerSettings-ps3TrophyCommSig", "PS3 Trophy Communication Signature." },
{ "PlayerSettings-ps3TrophyPackagePath", "PS3 Trophy Package." },
{ "PlayerSettings-psp2BackgroundPath", "Deprecated." },
{ "PlayerSettings-psp2DLCConfigPath", "Deprecated." },
{ "PlayerSettings-psp2NPCommsID", "PS Vita NP Communications ID." },
{ "PlayerSettings-psp2NPCommsPassphrase", "PS Vita NP Passphrase." },
{ "PlayerSettings-psp2NPCommsSig", "PS Vita NP Signature." },
{ "PlayerSettings-psp2NPTrophyPackPath", "Path specifying wher to copy a trophy pack from." },
{ "PlayerSettings-psp2PackagePassword", "32 character password for use if you want to access the contents of a package." },
{ "PlayerSettings-psp2ParamSfxPath", "Path specifying where to copy the package parameter file (param.sfx) from." },
{ "PlayerSettings-psp2SoundPath", "Deprecated." },
{ "PlayerSettings-psp2ThumbnailPath", "Deprecated." },
{ "PlayerSettings-psp2TrophyCommId", "Deprecated." },
{ "PlayerSettings-psp2TrophyPackagePath", "Deprecated." },
{ "PlayerSettings-renderingPath", "Which rendering path is enabled?" },
{ "PlayerSettings-resizableWindow", "Use resizable window in standalone player builds." },
{ "PlayerSettings-resolutionDialogBanner", "The image to display in the Resolution Dialog window." },
{ "PlayerSettings-runInBackground", "If enabled, your game will continue to run after lost focus." },
{ "PlayerSettings-statusBarHidden", "Should status bar be hidden. Shared between iOS & Android platforms." },
{ "PlayerSettings-stereoscopic3D", "Should player render in stereoscopic 3d on supported hardware?" },
{ "PlayerSettings-stripPhysics", "Remove Physics code from player to save build size (Flash only)." },
{ "PlayerSettings-strippingLevel", "Managed code stripping level." },
{ "PlayerSettings-stripUnusedMeshComponents", "Should unused Mesh components be excluded from game build?" },
{ "PlayerSettings-use32BitDisplayBuffer", "32-bit Display Buffer is used." },
{ "PlayerSettings-useAnimatedAutorotation", "Let the OS autorotate the screen as the device orientation changes." },
{ "PlayerSettings-useDirect3D11", "Should Direct3D 11 be used when available?" },
{ "PlayerSettings-useMacAppStoreValidation", "Enable receipt validation for the Mac App Store." },
{ "PlayerSettings-usePlayerLog", "Write a log file with debugging information." },
{ "PlayerSettings-xboxDeployKinectHeadOrientation", "Xbox 360 Kinect Head Orientation file deployment." },
{ "PlayerSettings-xboxDeployKinectHeadPosition", "Xbox 360 Kinect Head Position file deployment." },
{ "PlayerSettings-xboxDeployKinectResources", "Xbox 360 Kinect resource file deployment." },
{ "PlayerSettings-xboxEnableAvatar", "Xbox 360 Avatars." },
{ "PlayerSettings-xboxEnableKinect", "Xbox 360 Kinect title flag - if false, the Kinect APIs are inactive." },
{ "PlayerSettings-xboxEnableKinectAutoTracking", "Xbox 360 Kinect automatic skeleton tracking." },
{ "PlayerSettings-xboxEnableSpeech", "Xbox 360 Kinect Enable Speech Engine." },
{ "PlayerSettings-xboxGenerateSpa", "Xbox 360 auto-generation of _SPAConfig.cs." },
{ "PlayerSettings-xboxImageXexFilePath", "Xbox 360 ImageXex override configuration file path." },
{ "PlayerSettings-xboxSpaFilePath", "Xbox 360 SPA file path." },
{ "PlayerSettings-xboxSpeechDB", "Xbox 360 Kinect Speech DB." },
{ "PlayerSettings-xboxSplashScreen", "Xbox 360 splash screen." },
{ "PlayerSettings-xboxTitleId", "Xbox 360 title id." },
{ "PlayerSettings.Android", "Android specific player settings." },
{ "PlayerSettings.Android-bundleVersionCode", "Android bundle version code." },
{ "PlayerSettings.Android-forceInternetPermission", "Force internet permission flag." },
{ "PlayerSettings.Android-forceSDCardPermission", "Force SD card permission." },
{ "PlayerSettings.Android-keyaliasName", "Android key alias name." },
{ "PlayerSettings.Android-keyaliasPass", "Android key alias password." },
{ "PlayerSettings.Android-keystoreName", "Android keystore name." },
{ "PlayerSettings.Android-keystorePass", "Android keystore password." },
{ "PlayerSettings.Android-licenseVerification", "License verification flag." },
{ "PlayerSettings.Android-minSdkVersion", "Minimal Android SDK version." },
{ "PlayerSettings.Android-preferredInstallLocation", "Preferred application install location." },
{ "PlayerSettings.Android-showActivityIndicatorOnLoading", "Application should show ActivityIndicator when loading." },
{ "PlayerSettings.Android-splashScreenScale", "Android splash screen scale mode." },
{ "PlayerSettings.Android-targetDevice", "Android target device." },
{ "PlayerSettings.Android-use24BitDepthBuffer", "24-bit Depth Buffer is used." },
{ "PlayerSettings.Android-useAPKExpansionFiles", "Use APK Expansion Files." },
{ "PlayerSettings.BlackBerry", "BlackBerry specific player settings." },
{ "PlayerSettings.BlackBerry-authorId", "Unique developer identification assigned by BlackBerry." },
{ "PlayerSettings.BlackBerry-cskPassword", "The keystore password used when communicating with BlackBerry." },
{ "PlayerSettings.BlackBerry-deviceAddress", "The address used when accessing the device." },
{ "PlayerSettings.BlackBerry-devicePassword", "The password used when accessing the device." },
{ "PlayerSettings.BlackBerry-saveLogPath", "The file system path that the device log will be saved to when it is downloaded." },
{ "PlayerSettings.BlackBerry-tokenAuthor", "The plaintext name of the author that is associated with the application." },
{ "PlayerSettings.BlackBerry-tokenExpires", "The date in which the debug token is set to expire." },
{ "PlayerSettings.BlackBerry-tokenPath", "File system path to the debug token that the editor is currently sourcing." },
{ "PlayerSettings.BlackBerry.HasCameraPermissions", "Returns true when camera access has been requested in the player settings." },
{ "PlayerSettings.BlackBerry.HasGPSPermissions", "Returns true when GPS permission has been requested in the player settings." },
{ "PlayerSettings.BlackBerry.HasIdentificationPermissions", "Returns true when access the device's Unique identifier has been requested." },
{ "PlayerSettings.BlackBerry.HasMicrophonePermissions", "Returns true if microphone access has been requested in player settings." },
{ "PlayerSettings.BlackBerry.HasSharedPermissions", "Returns true if shared permissions are requested in player settings." },
{ "PlayerSettings.BlackBerry.SetCameraPermissions", "Enable or disable camera permissions. (Will prompt user for access)." },
{ "PlayerSettings.BlackBerry.SetGPSPermissions", "Enable / Disable access to the device GPS. (Will prompt for user for access)." },
{ "PlayerSettings.BlackBerry.SetIdentificationPermissions", "Enable / Disable device identification permission. (Will prompt user for access)." },
{ "PlayerSettings.BlackBerry.SetMicrophonePermissions", "Enable / Disable microphone permission level. (Will prompt user for access)." },
{ "PlayerSettings.BlackBerry.SetSharedPermissions", "Enable / Disable access to QNX shared folders (accesible via the rst://drive)." },
{ "PlayerSettings.GetIconsForTargetGroup", "Returns the list of assigned icons for the specified platform." },
{ "PlayerSettings.GetIconSizesForTargetGroup", "Returns a list of icon sizes for the specified platform." },
{ "PlayerSettings.GetScriptingDefineSymbolsForGroup", "Get user-specified symbols for script compilation for the given build target group." },
{ "PlayerSettings.HasAspectRatio", "Returns whether or not the specified aspect ratio is enabled." },
{ "PlayerSettings.iOS", "iOS specific player settings." },
{ "PlayerSettings.iOS-applicationDisplayName", "iOS application display name." },
{ "PlayerSettings.iOS-exitOnSuspend", "Application should exit when suspended to background." },
{ "PlayerSettings.iOS-prerenderedIcon", "Icon is prerendered." },
{ "PlayerSettings.iOS-requiresPersistentWiFi", "Application requires persistent WiFi." },
{ "PlayerSettings.iOS-scriptCallOptimization", "Script calling optimization." },
{ "PlayerSettings.iOS-sdkVersion", "Active iOS SDK version used for build." },
{ "PlayerSettings.iOS-showActivityIndicatorOnLoading", "Application should show ActivityIndicator when loading." },
{ "PlayerSettings.iOS-statusBarStyle", "Status bar style." },
{ "PlayerSettings.iOS-targetDevice", "Targeted device." },
{ "PlayerSettings.iOS-targetOSVersion", "Deployment minimal version of iOS." },
{ "PlayerSettings.iOS-targetResolution", "Targeted resolution." },
{ "PlayerSettings.MTRendering", "Is multi-threaded rendering enabled?" },
{ "PlayerSettings.PS3", "PS3 specific player settings." },
{ "PlayerSettings.PS3-videoMemoryForVertexBuffers", "The amount of video memory (in MB) that is set aside for vertex data allocations. Allocations which do not fit into the area are allocated from system memory." },
{ "PlayerSettings.SamsungTV", "Samsung Smart TV specific Player Settings." },
{ "PlayerSettings.SamsungTV-deviceAddress", "The address used when accessing the device." },
{ "PlayerSettings.SetAspectRatio", "Enables the specified aspect ratio." },
{ "PlayerSettings.SetIconsForTargetGroup", "Assign a list of icons for the specified platform." },
{ "PlayerSettings.SetScriptingDefineSymbolsForGroup", "Set user-specified symbols for script compilation for the given build target group." },
{ "PlayerSettings.Tizen", "Tizen specific player settings." },
{ "PlayerSettings.Tizen.HasGPSPermissions", "Returns true when GPS permission has been requested in the player settings." },
{ "PlayerSettings.Tizen.HasMicrophonePermissions", "Returns true if microphone access has been requested in player settings." },
{ "PlayerSettings.Tizen.SetGPSPermissions", "Enable / Disable access to the device GPS. (Will prompt for user for access)." },
{ "PlayerSettings.Tizen.SetMicrophonePermissions", "Enable / Disable microphone permission level. (Will prompt user for access)." },
{ "PlayMode", "Used by Animation.Play function." },
{ "PlayMode.StopAll", "Will stop all animations that were started with this component before playing." },
{ "PlayMode.StopSameLayer", "Will stop all animations that were started in the same layer. This is the default when playing animations." },
{ "PolygonCollider2D", "Collider for 2D physics representing an arbitrary polygon defined by its vertices." },
{ "PolygonCollider2D-pathCount", "The number of paths in the polygon." },
{ "PolygonCollider2D-points", "Corner points that define the collider's shape in local space." },
{ "PolygonCollider2D.CreatePrimitive", "Creates as regular primitive polygon with the specified number of sides." },
{ "PolygonCollider2D.GetPath", "Get a path from the polygon by its index." },
{ "PolygonCollider2D.GetTotalPointCount", "Return the total number of points in the polygon in all paths." },
{ "PolygonCollider2D.SetPath", "Define a path by its constituent points." },
{ "PopupWindow", "Class used to display popup windows that inherit from PopupWindowContent." },
{ "PopupWindow.Show", "Show a popup with the given PopupWindowContent." },
{ "PopupWindowContent", "Class used to implement content for a popup window." },
{ "PopupWindowContent-editorWindow", "The EditorWindow that contains the popup content." },
{ "PopupWindowContent.GetWindowSize", "The size of the popup window." },
{ "PopupWindowContent.OnClose", "Callback when the popup window is closed." },
{ "PopupWindowContent.OnGUI", "Callback for drawing GUI controls for the popup window." },
{ "PopupWindowContent.OnOpen", "Callback when the popup window is opened." },
{ "PrefabType", "The type of a prefab object as returned by EditorUtility.GetPrefabType." },
{ "PrefabType.DisconnectedModelPrefabInstance", "The object is an instance of an imported 3D model, but the connection is broken." },
{ "PrefabType.DisconnectedPrefabInstance", "The object is an instance of a user created prefab, but the connection is broken." },
{ "PrefabType.MissingPrefabInstance", "The object was an instance of a prefab, but the original prefab could not be found." },
{ "PrefabType.ModelPrefab", "The object is an imported 3D model asset." },
{ "PrefabType.ModelPrefabInstance", "The object is an instance of an imported 3D model." },
{ "PrefabType.None", "The object is not a prefab nor an instance of a prefab." },
{ "PrefabType.Prefab", "The object is a user created prefab asset." },
{ "PrefabType.PrefabInstance", "The object is an instance of a user created prefab." },
{ "PrefabUtility", "Utility class for any prefab related operations." },
{ "PrefabUtility.CreateEmptyPrefab", "Creates an empty prefab at given path." },
{ "PrefabUtility.CreatePrefab", "Creates a prefab from a game object hierarchy." },
{ "PrefabUtility.DisconnectPrefabInstance", "Disconnects the prefab instance from its parent prefab." },
{ "PrefabUtility.FindPrefabRoot", "Helper function to find the prefab root of an object (used for picking niceness)." },
{ "PrefabUtility.FindRootGameObjectWithSameParentPrefab", "Returns the topmost game object that has the same prefab parent as target." },
{ "PrefabUtility.FindValidUploadPrefabInstanceRoot", "Returns root game object of the prefab instance if that root prefab instance is a parent of the prefab." },
{ "PrefabUtility.GetPrefabObject", "Retrieves the enclosing prefab for any object contained within." },
{ "PrefabUtility.GetPrefabParent", "Returns the GameObject parent of source, or null if it can't be found." },
{ "PrefabUtility.GetPrefabType", "Given an object, returns its prefab type (None, if it's not a prefab)." },
{ "PrefabUtility.GetPropertyModifications", "Extract all modifications that are applied to the prefab instance compared to the parent prefab." },
{ "PrefabUtility.InstantiateAttachedAsset", "Instantiate an asset that is referenced by a prefab and use it on the prefab instance." },
{ "PrefabUtility.InstantiatePrefab", "Instantiates the given prefab." },
{ "PrefabUtility.MergeAllPrefabInstances", "Force re-merging all prefab instances of this prefab." },
{ "PrefabUtility.ReconnectToLastPrefab", "Connects the game object to the prefab that it was last connected to." },
{ "PrefabUtility.RecordPrefabInstancePropertyModifications", "Force record property modifications by comparing against the parent prefab." },
{ "PrefabUtility.ReplacePrefab", "Replaces the targetPrefab with a copy of the game object hierarchy go." },
{ "PrefabUtility.ResetToPrefabState", "Resets the properties of the component or game object to the parent prefab state." },
{ "PrefabUtility.RevertPrefabInstance", "Resets the properties of all objects in the prefab, including child game objects and components that were added to the prefab instance." },
{ "PrefabUtility.SetPropertyModifications", "Assigns all modifications that are applied to the prefab instance compared to the parent prefab." },
{ "PreferenceItem", "The PreferenceItem attribute allows you to add preferences sections to the Preferences Window." },
{ "PreferenceItem-ctor", "Creates a section in the Preferences Window called name and invokes the static function following it for the section's GUI." },
{ "PrimitiveType", "The various primitives that can be created using the GameObject.CreatePrimitive function." },
{ "PrimitiveType.Capsule", "A capsule primitive." },
{ "PrimitiveType.Cube", "A cube primitive." },
{ "PrimitiveType.Cylinder", "A cylinder primitive." },
{ "PrimitiveType.Plane", "A plane primitive." },
{ "PrimitiveType.Quad", "A Quad primitive." },
{ "PrimitiveType.Sphere", "A sphere primitive." },
{ "ProceduralCacheSize", "Substance memory budget." },
{ "ProceduralCacheSize.Heavy", "A limit of 512MB for the cache or the working memory." },
{ "ProceduralCacheSize.Medium", "A limit of 256MB for the cache or the working memory." },
{ "ProceduralCacheSize.NoLimit", "No limit for the cache or the working memory." },
{ "ProceduralCacheSize.None", "A limit of 1B (one byte) for the cache or the working memory." },
{ "ProceduralCacheSize.Tiny", "A limit of 128MB for the cache or the working memory." },
{ "ProceduralLoadingBehavior", "ProceduralMaterial loading behavior." },
{ "ProceduralLoadingBehavior.BakeAndDiscard", "Bake the textures to speed up loading and discard the ProceduralMaterial data (default on unsupported platform)." },
{ "ProceduralLoadingBehavior.BakeAndKeep", "Bake the textures to speed up loading and keep the ProceduralMaterial data so that it can still be tweaked and regenerated later on." },
{ "ProceduralLoadingBehavior.Cache", "Generate the textures when loading and cache them to disk/flash to speed up subsequent game/application startups." },
{ "ProceduralLoadingBehavior.DoNothing", "Do not generate the textures. RebuildTextures() or RebuildTexturesImmediately() must be called to generate the textures." },
{ "ProceduralLoadingBehavior.DoNothingAndCache", "Do not generate the textures. RebuildTextures() or RebuildTexturesImmediately() must be called to generate the textures. After the textures have been generrated for the first time, they are cached to disk/flash to speed up subsequent game/application startups." },
{ "ProceduralLoadingBehavior.Generate", "Generate the textures when loading to favor application's size (default on supported platform)." },
{ "ProceduralMaterial", "Class for ProceduralMaterial handling." },
{ "ProceduralMaterial-animationUpdateRate", "Set or get the update rate in millisecond of the animated substance." },
{ "ProceduralMaterial-cacheSize", "Set or get the Procedural cache budget." },
{ "ProceduralMaterial-isCachedDataAvailable", "Indicates whether cached data is available for this ProceduralMaterial's textures (only relevant for Cache and DoNothingAndCache loading behaviors)." },
{ "ProceduralMaterial-isLoadTimeGenerated", "Should the ProceduralMaterial be generated at load time?" },
{ "ProceduralMaterial-isProcessing", "Check if the ProceduralTextures from this ProceduralMaterial are currently being rebuilt." },
{ "ProceduralMaterial-isReadable", "Set or get the \"Readable\" flag for a ProceduralMaterial." },
{ "ProceduralMaterial-isSupported", "Check if ProceduralMaterials are supported on the current platform." },
{ "ProceduralMaterial-loadingBehavior", "Get ProceduralMaterial loading behavior." },
{ "ProceduralMaterial-preset", "Set or get an XML string of \"input/value\" pairs (setting the preset rebuilds the textures)." },
{ "ProceduralMaterial-substanceProcessorUsage", "Used to specify the Substance engine CPU usage." },
{ "ProceduralMaterial.CacheProceduralProperty", "Specifies if a named ProceduralProperty should be cached for efficient runtime tweaking." },
{ "ProceduralMaterial.ClearCache", "Clear the Procedural cache." },
{ "ProceduralMaterial.GetGeneratedTexture", "This allows to get a reference to a ProceduralTexture generated by a ProceduralMaterial using its name." },
{ "ProceduralMaterial.GetGeneratedTextures", "Get generated textures." },
{ "ProceduralMaterial.GetProceduralBoolean", "Get a named Procedural boolean property." },
{ "ProceduralMaterial.GetProceduralColor", "Get a named Procedural color property." },
{ "ProceduralMaterial.GetProceduralEnum", "Get a named Procedural enum property." },
{ "ProceduralMaterial.GetProceduralFloat", "Get a named Procedural float property." },
{ "ProceduralMaterial.GetProceduralPropertyDescriptions", "Get an array of descriptions of all the ProceduralProperties this ProceduralMaterial has." },
{ "ProceduralMaterial.GetProceduralTexture", "Get a named Procedural texture property." },
{ "ProceduralMaterial.GetProceduralVector", "Get a named Procedural vector property." },
{ "ProceduralMaterial.HasProceduralProperty", "Checks if the ProceduralMaterial has a ProceduralProperty of a given name." },
{ "ProceduralMaterial.IsProceduralPropertyCached", "Checks if a named ProceduralProperty is cached for efficient runtime tweaking." },
{ "ProceduralMaterial.RebuildTextures", "Triggers an asynchronous rebuild of this ProceduralMaterial's dirty textures." },
{ "ProceduralMaterial.RebuildTexturesImmediately", "Triggers an immediate (synchronous) rebuild of this ProceduralMaterial's dirty textures." },
{ "ProceduralMaterial.SetProceduralBoolean", "Set a named Procedural boolean property." },
{ "ProceduralMaterial.SetProceduralColor", "Set a named Procedural color property." },
{ "ProceduralMaterial.SetProceduralEnum", "Set a named Procedural enum property." },
{ "ProceduralMaterial.SetProceduralFloat", "Set a named Procedural float property." },
{ "ProceduralMaterial.SetProceduralTexture", "Set a named Procedural texture property." },
{ "ProceduralMaterial.SetProceduralVector", "Set a named Procedural vector property." },
{ "ProceduralMaterial.StopRebuilds", "Discard all the queued ProceduralMaterial rendering operations that have not started yet." },
{ "ProceduralOutputType", "The type of generated image in a ProceduralMaterial." },
{ "ProceduralOutputType.Diffuse", "Diffuse type." },
{ "ProceduralOutputType.Emissive", "Emmisive type." },
{ "ProceduralOutputType.Height", "HeightMap type." },
{ "ProceduralOutputType.Normal", "NormalMap (BumpMap) type." },
{ "ProceduralOutputType.Opacity", "Opacity (Tranparence) type." },
{ "ProceduralOutputType.Specular", "Specular (GlossMap) type." },
{ "ProceduralOutputType.Unknown", "Undefined type." },
{ "ProceduralProcessorUsage", "The global Substance engine processor usage (as used for the ProceduralMaterial.substanceProcessorUsage property)." },
{ "ProceduralProcessorUsage.All", "All physical processor cores are used for ProceduralMaterial generation." },
{ "ProceduralProcessorUsage.Half", "Half of all physical processor cores are used for ProceduralMaterial generation." },
{ "ProceduralProcessorUsage.One", "A single physical processor core is used for ProceduralMaterial generation." },
{ "ProceduralProcessorUsage.Unsupported", "Exact control of processor usage is not available." },
{ "ProceduralPropertyDescription", "Describes a ProceduralProperty." },
{ "ProceduralPropertyDescription-componentLabels", "The names of the individual components of a Vector2/3/4 ProceduralProperty." },
{ "ProceduralPropertyDescription-enumOptions", "The available options for a ProceduralProperty of type Enum." },
{ "ProceduralPropertyDescription-group", "The name of the GUI group. Used to display ProceduralProperties in groups." },
{ "ProceduralPropertyDescription-hasRange", "If true, the Float or Vector property is constrained to values within a specified range." },
{ "ProceduralPropertyDescription-label", "The label of the ProceduralProperty. Can contain space and be overall more user-friendly than the 'name' member." },
{ "ProceduralPropertyDescription-maximum", "If hasRange is true, maximum specifies the maximum allowed value for this Float or Vector property." },
{ "ProceduralPropertyDescription-minimum", "If hasRange is true, minimum specifies the minimum allowed value for this Float or Vector property." },
{ "ProceduralPropertyDescription-name", "The name of the ProceduralProperty. Used to get and set the values." },
{ "ProceduralPropertyDescription-step", "Specifies the step size of this Float or Vector property. Zero is no step." },
{ "ProceduralPropertyDescription-type", "The ProceduralPropertyType describes what type of property this is." },
{ "ProceduralPropertyType", "The type of a ProceduralProperty." },
{ "ProceduralPropertyType.Boolean", "Procedural boolean property. Use with ProceduralMaterial.GetProceduralBoolean." },
{ "ProceduralPropertyType.Color3", "Procedural Color property without alpha. Use with ProceduralMaterial.GetProceduralColor." },
{ "ProceduralPropertyType.Color4", "Procedural Color property with alpha. Use with ProceduralMaterial.GetProceduralColor." },
{ "ProceduralPropertyType.Enum", "Procedural Enum property. Use with ProceduralMaterial.GetProceduralEnum." },
{ "ProceduralPropertyType.Float", "Procedural float property. Use with ProceduralMaterial.GetProceduralFloat." },
{ "ProceduralPropertyType.Texture", "Procedural Texture property. Use with ProceduralMaterial.GetProceduralTexture." },
{ "ProceduralPropertyType.Vector2", "Procedural Vector2 property. Use with ProceduralMaterial.GetProceduralVector." },
{ "ProceduralPropertyType.Vector3", "Procedural Vector3 property. Use with ProceduralMaterial.GetProceduralVector." },
{ "ProceduralPropertyType.Vector4", "Procedural Vector4 property. Use with ProceduralMaterial.GetProceduralVector." },
{ "ProceduralTexture", "Class for ProceduralTexture handling." },
{ "ProceduralTexture-format", "The format of the pixel data in the texture (Read Only)." },
{ "ProceduralTexture-hasAlpha", "Check whether the ProceduralMaterial that generates this ProceduralTexture is set to an output format with an alpha channel." },
{ "ProceduralTexture.GetPixels32", "Grab pixel values from a ProceduralTexture." },
{ "ProceduralTexture.GetProceduralOutputType", "The output type of this ProceduralTexture." },
{ "Profiler", "Controls the Profiler from script." },
{ "Profiler-enableBinaryLog", "Sets profiler output file in built players." },
{ "Profiler-enabled", "Enables the Profiler." },
{ "Profiler-logFile", "Sets profiler output file in built players." },
{ "Profiler-usedHeapSize", "Heap size used by the program." },
{ "Profiler.AddFramesFromFile", "Displays the recorded profiledata in the profiler." },
{ "Profiler.BeginSample", "Begin profiling a piece of code with a custom label." },
{ "Profiler.EndSample", "End profiling a piece of code with a custom label." },
{ "Profiler.GetMonoHeapSize", "Returns the size of the mono heap." },
{ "Profiler.GetMonoUsedSize", "Returns the used size from mono." },
{ "Profiler.GetRuntimeMemorySize", "Returns the runtime memory usage of the resource." },
{ "Projector", "A script interface for a projector component." },
{ "Projector-aspectRatio", "The aspect ratio of the projection." },
{ "Projector-farClipPlane", "The far clipping plane distance." },
{ "Projector-fieldOfView", "The field of view of the projection in degrees." },
{ "Projector-ignoreLayers", "Which object layers are ignored by the projector." },
{ "Projector-material", "The material that will be projected onto every object." },
{ "Projector-nearClipPlane", "The near clipping plane distance." },
{ "Projector-orthographic", "Is the projection orthographic (true) or perspective (false)?" },
{ "Projector-orthographicSize", "Projection's half-size when in orthographic mode." },
{ "Projector-orthoGraphicSize", "Projection's half-size when in orthographic mode." },
{ "PropertyAttribute", "Base class to derive custom property attributes from. Use this to create custom attributes for script variables." },
{ "PropertyAttribute-order", "Optional field to specify the order that multiple DecorationDrawers should be drawn in." },
{ "PropertyDrawer", "Base class to derive custom property drawers from. Use this to create custom drawers for your own Serializable classes or for script variables with custom PropertyAttributes." },
{ "PropertyDrawer-attribute", "The PropertyAttribute for the property. Not applicable for custom class drawers. (Read Only)" },
{ "PropertyDrawer-fieldInfo", "The reflection FieldInfo for the member this property represents. (Read Only)" },
{ "PropertyDrawer.GetPropertyHeight", "Override this method to specify how tall the GUI for this field is in pixels." },
{ "PropertyDrawer.OnGUI", "Override this method to make your own GUI for the property." },
{ "PropertyModification", "Defines a single modified property." },
{ "PropertyModification-objectReference", "The value being applied when it is a object reference (which can not be represented as a string)." },
{ "PropertyModification-propertyPath", "Property path of the property being modified (Matches as SerializedProperty.propertyPath)." },
{ "PropertyModification-target", "Object that will be modified." },
{ "PropertyModification-value", "The value being applied." },
{ "PSP2BuildSubtarget", "Target PS Vita build type." },
{ "PSP2BuildSubtarget.Package", "For building a PS Vita package that can be installed on a PS Vita memory card." },
{ "PSP2BuildSubtarget.PCHosted", "For general development, creates a build stored on the host PC which the Vita reads from." },
{ "QualitySettings", "Script interface for Quality Settings." },
{ "QualitySettings-activeColorSpace", "Active color space." },
{ "QualitySettings-anisotropicFiltering", "Global anisotropic filtering mode." },
{ "QualitySettings-antiAliasing", "Set The AA Filtering option." },
{ "QualitySettings-blendWeights", "Blend weights." },
{ "QualitySettings-desiredColorSpace", "Desired color space." },
{ "QualitySettings-lodBias", "Global multiplier for the LOD's switching distance." },
{ "QualitySettings-masterTextureLimit", "A texture size limit applied to all textures." },
{ "QualitySettings-maximumLODLevel", "A maximum LOD level. All LOD groups." },
{ "QualitySettings-maxQueuedFrames", "Maximum number of frames queued up by graphics driver." },
{ "QualitySettings-names", "The indexed list of available Quality Settings." },
{ "QualitySettings-particleRaycastBudget", "Budget for how many ray casts can be performed per frame for approximate collision testing." },
{ "QualitySettings-pixelLightCount", "The maximum number of pixel lights that should affect any object." },
{ "QualitySettings-shadowCascades", "Number of cascades to use for directional light shadows." },
{ "QualitySettings-shadowDistance", "Shadow drawing distance." },
{ "QualitySettings-shadowProjection", "Directional light shadow projection." },
{ "QualitySettings-softVegetation", "Use a two-pass shader for the vegetation in the terrain engine." },
{ "QualitySettings-vSyncCount", "The VSync Count." },
{ "QualitySettings.DecreaseLevel", "Decrease the current quality level." },
{ "QualitySettings.GetQualityLevel", "Returns the current graphics quality level." },
{ "QualitySettings.IncreaseLevel", "Increase the current quality level." },
{ "QualitySettings.SetQualityLevel", "Sets a new graphics quality level." },
{ "Quaternion", "Quaternions are used to represent rotations." },
{ "Quaternion-ctor", "Constructs new Quaternion with given x,y,z,w components." },
{ "Quaternion-eulerAngles", "Returns the euler angle representation of the rotation." },
{ "Quaternion-identity", "The identity rotation (Read Only). This quaternion corresponds to \"no rotation\": the object." },
{ "Quaternion-operator_eq", "Are two quaternions equal to each other?" },
{ "Quaternion-operator_multiply", "Combines rotations lhs and rhs." },
{ "Quaternion-operator_ne", "Are two quaternions different from each other?" },
{ "Quaternion-w", "W component of the Quaternion. Don't modify this directly unless you know quaternions inside out." },
{ "Quaternion-x", "X component of the Quaternion. Don't modify this directly unless you know quaternions inside out." },
{ "Quaternion-y", "Y component of the Quaternion. Don't modify this directly unless you know quaternions inside out." },
{ "Quaternion-z", "Z component of the Quaternion. Don't modify this directly unless you know quaternions inside out." },
{ "Quaternion.Angle", "Returns the angle in degrees between two rotations a and b." },
{ "Quaternion.AngleAxis", "Creates a rotation which rotates angle degrees around axis." },
{ "Quaternion.Dot", "The dot product between two rotations." },
{ "Quaternion.Euler", "Returns a rotation that rotates z degrees around the z axis, x degrees around the x axis, and y degrees around the y axis (in that order)." },
{ "Quaternion.FromToRotation", "Creates a rotation which rotates from fromDirection to toDirection." },
{ "Quaternion.Index_operator", "Access the x, y, z, w components using [0], [1], [2], [3] respectively." },
{ "Quaternion.Inverse", "Returns the Inverse of rotation." },
{ "Quaternion.Lerp", "Interpolates between from and to by t and normalizes the result afterwards." },
{ "Quaternion.LookRotation", "Creates a rotation with the specified forward and upwards directions." },
{ "Quaternion.RotateTowards", "Rotates a rotation from towards to." },
{ "Quaternion.Set", "Set x, y, z and w components of an existing Quaternion." },
{ "Quaternion.SetFromToRotation", "Creates a rotation which rotates from fromDirection to toDirection." },
{ "Quaternion.SetLookRotation", "Creates a rotation with the specified forward and upwards directions." },
{ "Quaternion.Slerp", "Spherically interpolates between from and to by t." },
{ "Quaternion.ToAngleAxis", "Converts a rotation to angle-axis representation." },
{ "Quaternion.ToString", "Returns a nicely formatted string of the Quaternion." },
{ "QueueMode", "Used by Animation.Play function." },
{ "QueueMode.CompleteOthers", "Will start playing after all other animations have stopped playing." },
{ "QueueMode.PlayNow", "Starts playing immediately. This can be used if you just want to quickly create a duplicate animation." },
{ "Random", "Class for generating random data." },
{ "Random-insideUnitCircle", "Returns a random point inside a circle with radius 1 (Read Only)." },
{ "Random-insideUnitSphere", "Returns a random point inside a sphere with radius 1 (Read Only)." },
{ "Random-onUnitSphere", "Returns a random point on the surface of a sphere with radius 1 (Read Only)." },
{ "Random-rotation", "Returns a random rotation (Read Only)." },
{ "Random-rotationUniform", "Returns a random rotation with uniform distribution (Read Only)." },
{ "Random-seed", "Sets the seed for the random number generator." },
{ "Random-value", "Returns a random number between 0.0 [inclusive] and 1.0 [inclusive] (Read Only)." },
{ "Random.Range", "Returns a random float number between and min [inclusive] and max [inclusive] (Read Only)." },
{ "RangeAttribute", "Attribute used to make a float or int variable in a script be restricted to a specific range." },
{ "RangeAttribute-ctor", "Attribute used to make a float or int variable in a script be restricted to a specific range." },
{ "Ray", "Representation of rays." },
{ "Ray-ctor", "Creates a ray starting at origin along direction." },
{ "Ray-direction", "The direction of the ray." },
{ "Ray-origin", "The origin point of the ray." },
{ "Ray.GetPoint", "Returns a point at distance units along the ray." },
{ "Ray.ToString", "Returns a nicely formatted string for this ray." },
{ "Ray2D", "A ray in 2D space." },
{ "Ray2D-direction", "The direction of the ray in world space." },
{ "Ray2D-origin", "The starting point of the ray in world space." },
{ "Ray2D.GetPoint", "Get a point that lies a given distance along a ray." },
{ "RaycastHit", "Structure used to get information back from a raycast." },
{ "RaycastHit-barycentricCoordinate", "The barycentric coordinate of the triangle we hit." },
{ "RaycastHit-collider", "The Collider that was hit." },
{ "RaycastHit-distance", "The distance from the ray's origin to the impact point." },
{ "RaycastHit-lightmapCoord", "The uv lightmap coordinate at the impact point." },
{ "RaycastHit-normal", "The normal of the surface the ray hit." },
{ "RaycastHit-point", "The impact point in world space where the ray hit the collider." },
{ "RaycastHit-rigidbody", "The Rigidbody of the collider that was hit. If the collider is not attached to a rigidbody then it is null." },
{ "RaycastHit-textureCoord", "The uv texture coordinate at the impact point." },
{ "RaycastHit-textureCoord2", "The secondary uv texture coordinate at the impact point." },
{ "RaycastHit-transform", "The Transform of the rigidbody or collider that was hit." },
{ "RaycastHit-triangleIndex", "The index of the triangle that was hit." },
{ "RaycastHit2D", "Information returned about an object detected by a raycast in 2D physics." },
{ "RaycastHit2D-centroid", "The centroid of the primitive used to perform the cast." },
{ "RaycastHit2D-collider", "The collider hit by the ray." },
{ "RaycastHit2D-fraction", "Fraction of the distance along the ray that the hit occurred." },
{ "RaycastHit2D-normal", "The normal vector of the surface hit by the ray." },
{ "RaycastHit2D-point", "The point in world space where the ray hit the collider's surface." },
{ "RaycastHit2D-rigidbody", "The Rigidbody2D attached to the object that was hit." },
{ "RaycastHit2D-transform", "The Transform of the object that was hit." },
{ "Rect", "A 2D Rectangle defined by x, y position and width, height." },
{ "Rect-center", "Center coordinate of the rectangle." },
{ "Rect-ctor", "Creates a new rectangle." },
{ "Rect-height", "Height of the rectangle." },
{ "Rect-max", "Upper right corner of the rectangle." },
{ "Rect-min", "Lower left corner of the rectangle." },
{ "Rect-operator_eq", "Returns true if the rectangles are the same." },
{ "Rect-operator_ne", "Returns true if the rectangles are different." },
{ "Rect-position", "The top left coordinates of the rectangle." },
{ "Rect-size", "The size of the rectangle." },
{ "Rect-width", "Width of the rectangle." },
{ "Rect-x", "Left coordinate of the rectangle." },
{ "Rect-xMax", "Right coordinate of the rectangle." },
{ "Rect-xMin", "Left coordinate of the rectangle." },
{ "Rect-y", "Top coordinate of the rectangle." },
{ "Rect-yMax", "Bottom coordinate of the rectangle." },
{ "Rect-yMin", "Top coordinate of the rectangle." },
{ "Rect.Contains", "Returns true if the x and y components of point is a point inside this rectangle. If allowInverse is present and true, the width and height of the Rect are allowed to take negative values (ie, the min value is greater than the max), and the test will still work." },
{ "Rect.MinMaxRect", "Creates a rectangle from min/max coordinate values." },
{ "Rect.NormalizedToPoint", "Returns a point inside a rectangle, given normalized coordinates." },
{ "Rect.Overlaps", "Returns true if the other rectangle overlaps this one. If allowInverse is present and true, the widths and heights of the Rects are allowed to take negative values (ie, the min value is greater than the max), and the test will still work." },
{ "Rect.PointToNormalized", "Returns the normalized coordinates cooresponding the the point." },
{ "Rect.Set", "Set components of an existing Rect." },
{ "Rect.ToString", "Returns a nicely formatted string for this Rect." },
{ "RectOffset", "Offsets for rectangles, borders, etc." },
{ "RectOffset-bottom", "Bottom edge size." },
{ "RectOffset-ctor", "Creates a new rectangle with offsets." },
{ "RectOffset-horizontal", "Shortcut for left + right. (Read Only)" },
{ "RectOffset-left", "Left edge size." },
{ "RectOffset-right", "Right edge size." },
{ "RectOffset-top", "Top edge size." },
{ "RectOffset-vertical", "Shortcut for top + bottom. (Read Only)" },
{ "RectOffset.Add", "Add the border offsets to a rect." },
{ "RectOffset.Remove", "Remove the border offsets from a rect." },
{ "RemoteNotification", "RemoteNotification is only available on iPhone/iPad/iPod Touch." },
{ "RemoteNotification-alertBody", "The message displayed in the notification alert. (Read Only)" },
{ "RemoteNotification-applicationIconBadgeNumber", "The number to display as the application's icon badge. (Read Only)" },
{ "RemoteNotification-hasAction", "A boolean value that controls whether the alert action is visible or not. (Read Only)" },
{ "RemoteNotification-soundName", "The name of the sound file to play when an alert is displayed. (Read Only)" },
{ "RemoteNotification-userInfo", "A dictionary for passing custom information to the notified application. (Read Only)" },
{ "RemoteNotificationType", "Specify remote notification types." },
{ "RemoteNotificationType.Alert", "The application accepts alert messages as notifications." },
{ "RemoteNotificationType.Badge", "The application accepts notifications that badge the application icon." },
{ "RemoteNotificationType.None", "The application accepts no notifications." },
{ "RemoteNotificationType.Sound", "The application accepts alert sounds as notifications." },
{ "RemoveAssetOptions.DeleteAssets", "Delete the asset without moving it to the trash." },
{ "RemoveAssetOptions.MoveAssetToTrash", "The asset should be moved to trash." },
{ "RenderBuffer", "Color or depth buffer part of a RenderTexture." },
{ "Renderer", "General functionality for all renderers." },
{ "Renderer-bounds", "The bounding volume of the renderer (Read Only)." },
{ "Renderer-castShadows", "Does this object cast shadows?" },
{ "Renderer-enabled", "Makes the rendered 3D object visible if enabled." },
{ "Renderer-isPartOfStaticBatch", "Has this renderer been statically batched with any other renderers?" },
{ "Renderer-isVisible", "Is this renderer visible in any camera? (Read Only)" },
{ "Renderer-lightmapIndex", "The index of the lightmap applied to this renderer." },
{ "Renderer-lightmapTilingOffset", "The tiling & offset used for lightmap." },
{ "Renderer-lightProbeAnchor", "If set, Renderer will use this Transform's position to find the interpolated light probe." },
{ "Renderer-localToWorldMatrix", "Matrix that transforms a point from local space into world space (Read Only)." },
{ "Renderer-material", "The material of this object." },
{ "Renderer-materials", "All the materials of this object." },
{ "Renderer-receiveShadows", "Does this object receive shadows?" },
{ "Renderer-sharedMaterial", "The shared material of this object." },
{ "Renderer-sharedMaterials", "All the shared materials of this object." },
{ "Renderer-sortingLayerID", "ID of the Renderer's sorting layer." },
{ "Renderer-sortingLayerName", "Name of the Renderer's sorting layer." },
{ "Renderer-sortingOrder", "Renderer's order within a sorting layer." },
{ "Renderer-useLightProbes", "Use light probes for this Renderer." },
{ "Renderer-worldToLocalMatrix", "Matrix that transforms a point from world space into local space (Read Only)." },
{ "Renderer.GetPropertyBlock", "Get per-renderer material property block." },
{ "Renderer.OnBecameInvisible", "OnBecameInvisible is called when the object is no longer visible by any camera." },
{ "Renderer.OnBecameVisible", "OnBecameVisible is called when the object became visible by any camera." },
{ "Renderer.SetPropertyBlock", "Lets you add per-renderer material parameters without duplicating a material." },
{ "Rendering.BlendMode", "Blend mode for controlling the blending." },
{ "Rendering.BlendMode.DstAlpha", "Blend factor is (Ad, Ad, Ad, Ad)." },
{ "Rendering.BlendMode.DstColor", "Blend factor is (Rd, Gd, Bd, Ad)." },
{ "Rendering.BlendMode.One", "Blend factor is (1, 1, 1, 1)." },
{ "Rendering.BlendMode.OneMinusDstAlpha", "Blend factor is (1 - Ad, 1 - Ad, 1 - Ad, 1 - Ad)." },
{ "Rendering.BlendMode.OneMinusDstColor", "Blend factor is (1 - Rd, 1 - Gd, 1 - Bd, 1 - Ad)." },
{ "Rendering.BlendMode.OneMinusSrcAlpha", "Blend factor is (1 - As, 1 - As, 1 - As, 1 - As)." },
{ "Rendering.BlendMode.OneMinusSrcColor", "Blend factor is (1 - Rs, 1 - Gs, 1 - Bs, 1 - As)." },
{ "Rendering.BlendMode.SrcAlpha", "Blend factor is (As, As, As, As)." },
{ "Rendering.BlendMode.SrcAlphaSaturate", "Blend factor is (f, f, f, 1); where f = min(As, 1 - Ad)." },
{ "Rendering.BlendMode.SrcColor", "Blend factor is (Rs, Gs, Bs, As)." },
{ "Rendering.BlendMode.Zero", "Blend factor is (0, 0, 0, 0)." },
{ "Rendering.BlendOp", "Blend operation." },
{ "Rendering.BlendOp.Add", "Add (s + d)." },
{ "Rendering.BlendOp.LogicalAnd", "Logical AND (s & d) (D3D11.1 only)." },
{ "Rendering.BlendOp.LogicalAndInverted", "Logical inverted AND (!s & d) (D3D11.1 only)." },
{ "Rendering.BlendOp.LogicalAndReverse", "Logical reverse AND (s & !d) (D3D11.1 only)." },
{ "Rendering.BlendOp.LogicalClear", "Logical Clear (0)." },
{ "Rendering.BlendOp.LogicalCopy", "Logical Copy (s) (D3D11.1 only)." },
{ "Rendering.BlendOp.LogicalCopyInverted", "Logical inverted Copy (!s) (D3D11.1 only)." },
{ "Rendering.BlendOp.LogicalEquivalence", "Logical Equivalence !(s XOR d) (D3D11.1 only)." },
{ "Rendering.BlendOp.LogicalInvert", "Logical Inverse (!d) (D3D11.1 only)." },
{ "Rendering.BlendOp.LogicalNand", "Logical NAND !(s & d). D3D11.1 only." },
{ "Rendering.BlendOp.LogicalNoop", "Logical No-op (d) (D3D11.1 only)." },
{ "Rendering.BlendOp.LogicalNor", "Logical NOR !(s | d) (D3D11.1 only)." },
{ "Rendering.BlendOp.LogicalOr", "Logical OR (s | d) (D3D11.1 only)." },
{ "Rendering.BlendOp.LogicalOrInverted", "Logical inverted OR (!s | d) (D3D11.1 only)." },
{ "Rendering.BlendOp.LogicalOrReverse", "Logical reverse OR (s | !d) (D3D11.1 only)." },
{ "Rendering.BlendOp.LogicalSet", "Logical SET (1) (D3D11.1 only)." },
{ "Rendering.BlendOp.LogicalXor", "Logical XOR (s XOR d) (D3D11.1 only)." },
{ "Rendering.BlendOp.Max", "Max." },
{ "Rendering.BlendOp.Min", "Min." },
{ "Rendering.BlendOp.ReverseSubtract", "Reverse subtract." },
{ "Rendering.BlendOp.Subtract", "Subtract." },
{ "Rendering.ColorWriteMask", "Specifies which color components will get written into the target framebuffer." },
{ "Rendering.ColorWriteMask.All", "Write all components (R, G, B and Alpha)." },
{ "Rendering.ColorWriteMask.Alpha", "Write alpha component." },
{ "Rendering.ColorWriteMask.Blue", "Write blue component." },
{ "Rendering.ColorWriteMask.Green", "Write green component." },
{ "Rendering.ColorWriteMask.Red", "Write red component." },
{ "Rendering.CompareFunction", "Depth or stencil comparison function." },
{ "Rendering.CompareFunction.Always", "Always pass depth or stencil test." },
{ "Rendering.CompareFunction.Disabled", "Depth or stencil test is disabled." },
{ "Rendering.CompareFunction.Equal", "Pass depth or stencil test when values are equal." },
{ "Rendering.CompareFunction.Greater", "Pass depth or stencil test when new value is greater than old one." },
{ "Rendering.CompareFunction.GreaterEqual", "Pass depth or stencil test when new value is greater or equal than old one." },
{ "Rendering.CompareFunction.Less", "Pass depth or stencil test when new value is less than old one." },
{ "Rendering.CompareFunction.LessEqual", "Pass depth or stencil test when new value is less or equal than old one." },
{ "Rendering.CompareFunction.Never", "Never pass depth or stencil test." },
{ "Rendering.CompareFunction.NotEqual", "Pass depth or stencil test when values are different." },
{ "Rendering.CullMode", "Backface culling mode." },
{ "Rendering.CullMode.Back", "Cull back-facing geometry." },
{ "Rendering.CullMode.Front", "Cull front-facing geometry." },
{ "Rendering.CullMode.Off", "Disable culling." },
{ "Rendering.StencilOp", "Specifies the operation that's performed on the stencil buffer when rendering." },
{ "Rendering.StencilOp.DecrementSaturate", "Decrements the current stencil buffer value. Clamps to 0." },
{ "Rendering.StencilOp.DecrementWrap", "Decrements the current stencil buffer value. Wraps stencil buffer value to the maximum representable unsigned value when decrementing a stencil buffer value of zero." },
{ "Rendering.StencilOp.IncrementSaturate", "Increments the current stencil buffer value. Clamps to the maximum representable unsigned value." },
{ "Rendering.StencilOp.IncrementWrap", "Increments the current stencil buffer value. Wraps stencil buffer value to zero when incrementing the maximum representable unsigned value." },
{ "Rendering.StencilOp.Invert", "Bitwise inverts the current stencil buffer value." },
{ "Rendering.StencilOp.Keep", "Keeps the current stencil value." },
{ "Rendering.StencilOp.Replace", "Replace the stencil buffer value with reference value (specified in the shader)." },
{ "Rendering.StencilOp.Zero", "Sets the stencil buffer value to zero." },
{ "RenderingPath", "Rendering path of a Camera." },
{ "RenderingPath.DeferredLighting", "Deferred Lighting." },
{ "RenderingPath.Forward", "Forward Rendering." },
{ "RenderingPath.UsePlayerSettings", "Use Player Settings." },
{ "RenderingPath.VertexLit", "Vertex Lit." },
{ "RenderSettings", "The Render Settings contain values for a range of visual elements in your scene, like fog and ambient light." },
{ "RenderSettings-ambientLight", "Color of the scene's ambient light." },
{ "RenderSettings-flareFadeSpeed", "The fade speed of all flares in the scene." },
{ "RenderSettings-flareStrength", "The intensity of all flares in the scene." },
{ "RenderSettings-fog", "Is fog enabled?" },
{ "RenderSettings-fogColor", "The color of the fog." },
{ "RenderSettings-fogDensity", "The density of the exponential fog." },
{ "RenderSettings-fogEndDistance", "The ending distance of linear fog." },
{ "RenderSettings-fogMode", "Fog mode to use." },
{ "RenderSettings-fogStartDistance", "The starting distance of linear fog." },
{ "RenderSettings-haloStrength", "Size of the Light halos." },
{ "RenderSettings-skybox", "The global skybox to use." },
{ "RenderTexture", "Render textures are textures that can be rendered to." },
{ "RenderTexture-active", "The active render texture." },
{ "RenderTexture-antiAliasing", "The antialiasing level for the RenderTexture." },
{ "RenderTexture-colorBuffer", "Color buffer of the render texture (Read Only)." },
{ "RenderTexture-ctor", "Creates a new RenderTexture object." },
{ "RenderTexture-depth", "The precision of the render texture's depth buffer in bits (0, 16, 24 are supported)." },
{ "RenderTexture-depthBuffer", "Depth buffer of the render texture (Read Only)." },
{ "RenderTexture-enableRandomWrite", "Enable DX11 random access write into this render texture." },
{ "RenderTexture-format", "The format of the render texture." },
{ "RenderTexture-generateMips", "Should mipmap levels be generated automatically?" },
{ "RenderTexture-height", "The height of the render texture in pixels." },
{ "RenderTexture-isCubemap", "If enabled, this Render Texture will be used as a Cubemap." },
{ "RenderTexture-isVolume", "If enabled, this Render Texture will be used as a Texture3D." },
{ "RenderTexture-sRGB", "Does this render texture use sRGB read / write (Read Only)." },
{ "RenderTexture-useMipMap", "Use mipmaps on a render texture?" },
{ "RenderTexture-volumeDepth", "Volume extent of a 3D render texture." },
{ "RenderTexture-width", "The width of the render texture in pixels." },
{ "RenderTexture.Create", "Actually creates the RenderTexture." },
{ "RenderTexture.DiscardContents", "Discards the contents of the RenderTexture." },
{ "RenderTexture.GetTemporary", "Allocate a temporary render texture." },
{ "RenderTexture.IsCreated", "Is the render texture actually created?" },
{ "RenderTexture.MarkRestoreExpected", "Indicate that there's a RenderTexture restore operation expected." },
{ "RenderTexture.Release", "Releases the RenderTexture." },
{ "RenderTexture.ReleaseTemporary", "Release a temporary texture allocated with GetTemporary." },
{ "RenderTexture.SetGlobalShaderProperty", "Assigns this RenderTexture as a global shader property named propertyName." },
{ "RenderTexture.SupportsStencil", "Does the RenderTexture have stencil buffer?" },
{ "RenderTextureFormat", "Format of a RenderTexture." },
{ "RenderTextureFormat.ARGB1555", "Color render texture format, 1 bit for Alpha channel, 5 bits for Red, Green and Blue channels." },
{ "RenderTextureFormat.ARGB32", "Color render texture format, 8 bits per channel." },
{ "RenderTextureFormat.ARGB4444", "Color render texture format, 4 bit per channel." },
{ "RenderTextureFormat.ARGBFloat", "Color render texture format, 32 bit floating point per channel." },
{ "RenderTextureFormat.ARGBHalf", "Color render texture format, 16 bit floating point per channel." },
{ "RenderTextureFormat.ARGBInt", "Four channel (ARGB) render texture format, 32 bit signed integer per channel." },
{ "RenderTextureFormat.Default", "Default color render texture format: will be chosen accordingly to Frame Buffer format and Platform." },
{ "RenderTextureFormat.DefaultHDR", "Default HDR color render texture format: will be chosen accordingly to Frame Buffer format and Platform." },
{ "RenderTextureFormat.Depth", "A depth render texture format." },
{ "RenderTextureFormat.R8", "Scalar (R) render texture format, 8 bit fixed point." },
{ "RenderTextureFormat.RFloat", "Scalar (R) render texture format, 32 bit floating point." },
{ "RenderTextureFormat.RGB565", "Color render texture format." },
{ "RenderTextureFormat.RGFloat", "Two color (RG) render texture format, 32 bit floating point per channel." },
{ "RenderTextureFormat.RGHalf", "Two color (RG) render texture format, 16 bit floating point per channel." },
{ "RenderTextureFormat.RGInt", "Two channel (RG) render texture format, 32 bit signed integer per channel." },
{ "RenderTextureFormat.RHalf", "Scalar (R) render texture format, 16 bit floating point." },
{ "RenderTextureFormat.RInt", "Scalar (R) render texture format, 32 bit signed integer." },
{ "RenderTextureReadWrite", "Read write mode of a RenderTexture." },
{ "RenderTextureReadWrite-sRGB", "sRGB reads and writes to this render texture." },
{ "RenderTextureReadWrite.Default", "The correct color space for the current position in the rendering pipeline." },
{ "RenderTextureReadWrite.Linear", "No sRGB reads or writes to this render texture." },
{ "ReplacePrefabOptions", "Flags for the PrefabUtility.ReplacePrefab function." },
{ "ReplacePrefabOptions.ConnectToPrefab", "Connects the passed objects to the prefab after uploading the prefab." },
{ "ReplacePrefabOptions.Default", "Replaces prefabs by matching pre-existing connections to the prefab." },
{ "ReplacePrefabOptions.ReplaceNameBased", "Replaces the prefab using name based lookup in the transform hierarchy." },
{ "RequireComponent", "The RequireComponent attribute lets automatically add required component as a dependency." },
{ "RequireComponent-ctor", "Require a single component." },
{ "Resolution", "Represents a display resolution." },
{ "Resolution-height", "Resolution height in pixels." },
{ "Resolution-refreshRate", "Resolution's vertical refresh rate in Hz." },
{ "Resolution-width", "Resolution width in pixels." },
{ "ResolutionDialogSetting", "Resolution dialog setting." },
{ "ResolutionDialogSetting.Disabled", "Never show the resolutions dialog." },
{ "ResolutionDialogSetting.Enabled", "Show the resolutions dialog on first launch." },
{ "ResolutionDialogSetting.HiddenByDefault", "Hide the resolutions dialog on first launch." },
{ "Resources", "The Resources class allows you to find and access Objects including assets." },
{ "Resources.FindObjectsOfTypeAll", "Returns a list of all objects of Type type." },
{ "Resources.Load", "Loads an asset stored at path in a Resources folder." },
{ "Resources.LoadAll", "Loads all assets in a folder or file at path in a Resources folder." },
{ "Resources.LoadAssetAtPath", "Returns a resource at an asset path (Editor Only)." },
{ "Resources.UnloadAsset", "Unloads assetToUnload from memory." },
{ "Resources.UnloadUnusedAssets", "Unloads assets that are not used." },
{ "Rigidbody", "Control of an object's position through physics simulation." },
{ "Rigidbody-angularDrag", "The angular drag of the object." },
{ "Rigidbody-angularVelocity", "The angular velocity vector of the rigidbody." },
{ "Rigidbody-centerOfMass", "The center of mass relative to the transform's origin." },
{ "Rigidbody-collisionDetectionMode", "The Rigidbody's collision detection mode." },
{ "Rigidbody-constraints", "Controls which degrees of freedom are allowed for the simulation of this Rigidbody." },
{ "Rigidbody-detectCollisions", "Should collision detection be enabled? (By default always enabled)." },
{ "Rigidbody-drag", "The drag of the object." },
{ "Rigidbody-freezeRotation", "Controls whether physics will change the rotation of the object." },
{ "Rigidbody-inertiaTensor", "The diagonal inertia tensor of mass relative to the center of mass." },
{ "Rigidbody-inertiaTensorRotation", "The rotation of the inertia tensor." },
{ "Rigidbody-interpolation", "Interpolation allows you to smooth out the effect of running physics at a fixed frame rate." },
{ "Rigidbody-isKinematic", "Controls whether physics affects the rigidbody." },
{ "Rigidbody-mass", "The mass of the rigidbody." },
{ "Rigidbody-maxAngularVelocity", "The maximimum angular velocity of the rigidbody. (Default 7) range { 0, infinity }." },
{ "Rigidbody-position", "The position of the rigidbody." },
{ "Rigidbody-rotation", "The rotation of the rigdibody." },
{ "Rigidbody-sleepAngularVelocity", "The angular velocity below which objects start going to sleep. (Default 0.14) range { 0, infinity }." },
{ "Rigidbody-sleepVelocity", "The linear velocity below which objects start going to sleep. (Default 0.14) range { 0, infinity }." },
{ "Rigidbody-solverIterationCount", "Allows you to override the solver iteration count per rigidbody." },
{ "Rigidbody-useConeFriction", "Force cone friction to be used for this rigidbody." },
{ "Rigidbody-useGravity", "Controls whether gravity affects this rigidbody." },
{ "Rigidbody-velocity", "The velocity vector of the rigidbody." },
{ "Rigidbody-worldCenterOfMass", "The center of mass of the rigidbody in world space (Read Only)." },
{ "Rigidbody.AddExplosionForce", "Applies a force to the rigidbody that simulates explosion effects. The explosion force will fall off linearly with distance to the rigidbody." },
{ "Rigidbody.AddForce", "Adds a force to the rigidbody. As a result the rigidbody will start moving." },
{ "Rigidbody.AddForceAtPosition", "Applies force at position. As a result this will apply a torque and force on the object." },
{ "Rigidbody.AddRelativeForce", "Adds a force to the rigidbody relative to its coordinate system." },
{ "Rigidbody.AddRelativeTorque", "Adds a torque to the rigidbody relative to the rigidbodie's own coordinate system." },
{ "Rigidbody.AddTorque", "Adds a torque to the rigidbody." },
{ "Rigidbody.ClosestPointOnBounds", "The closest point to the bounding box of the attached colliders." },
{ "Rigidbody.GetPointVelocity", "The velocity of the rigidbody at the point worldPoint in global space." },
{ "Rigidbody.GetRelativePointVelocity", "The velocity relative to the rigidbody at the point relativePoint." },
{ "Rigidbody.IsSleeping", "Is the rigidbody sleeping?" },
{ "Rigidbody.MovePosition", "Moves the rigidbody to position." },
{ "Rigidbody.MoveRotation", "Rotates the rigidbody to rotation." },
{ "Rigidbody.OnCollisionEnter", "OnCollisionEnter is called when this collider/rigidbody has begun touching another rigidbody/collider." },
{ "Rigidbody.OnCollisionExit", "OnCollisionEnter is called when this collider/rigidbody has stopped touching another rigidbody/collider." },
{ "Rigidbody.OnCollisionStay", "OnCollisionStay is called once per frame for every collider/rigidbody that is touching rigidbody/collider." },
{ "Rigidbody.SetDensity", "Sets the mass based on the attached colliders assuming a constant density." },
{ "Rigidbody.Sleep", "Forces a rigidbody to sleep at least one frame." },
{ "Rigidbody.SweepTest", "Tests if a rigidbody would collide with anything, if it was moved through the scene." },
{ "Rigidbody.SweepTestAll", "Like Rigidbody.SweepTest, but returns all hits." },
{ "Rigidbody.WakeUp", "Forces a rigidbody to wake up." },
{ "Rigidbody2D", "Rigidbody physics component for 2D sprites." },
{ "Rigidbody2D-angularDrag", "Coefficient of angular drag." },
{ "Rigidbody2D-angularVelocity", "Angular velocity in degrees per second." },
{ "Rigidbody2D-centerOfMass", "The center of mass of the rigidBody in local space." },
{ "Rigidbody2D-collisionDetectionMode", "The method used by the physics engine to check if two objects have collided." },
{ "Rigidbody2D-drag", "Coefficient of drag." },
{ "Rigidbody2D-fixedAngle", "Should the rigidbody be prevented from rotating?" },
{ "Rigidbody2D-gravityScale", "The degree to which this object is affected by gravity." },
{ "Rigidbody2D-inertia", "The rigidBody rotational inertia." },
{ "Rigidbody2D-interpolation", "Physics interpolation used between updates." },
{ "Rigidbody2D-isKinematic", "Should this rigidbody be taken out of physics control?" },
{ "Rigidbody2D-mass", "Mass of the rigidbody." },
{ "Rigidbody2D-position", "The position of the rigidbody." },
{ "Rigidbody2D-rotation", "The rotation of the rigdibody." },
{ "Rigidbody2D-simulated", "Indicates whether the rigid body should be simulated or not by the physics system." },
{ "Rigidbody2D-sleepMode", "The sleep state that the rigidbody will initially be in." },
{ "Rigidbody2D-velocity", "Linear velocity of the rigidbody." },
{ "Rigidbody2D-worldCenterOfMass", "Gets the center of mass of the rigidBody in global space." },
{ "Rigidbody2D.AddForce", "Apply a force to the rigidbody." },
{ "Rigidbody2D.AddForceAtPosition", "Apply a force at a given position in space." },
{ "Rigidbody2D.AddRelativeForce", "Adds a force to the rigidbody2D relative to its coordinate system." },
{ "Rigidbody2D.AddTorque", "Apply a torque at the rigidbody's centre of mass." },
{ "Rigidbody2D.GetPoint", "Get a local space point given the point point in rigidBody global space." },
{ "Rigidbody2D.GetPointVelocity", "The velocity of the rigidbody at the point Point in global space." },
{ "Rigidbody2D.GetRelativePoint", "Get a global space point given the point relativePoint in rigidBody local space." },
{ "Rigidbody2D.GetRelativePointVelocity", "The velocity of the rigidbody at the point Point in local space." },
{ "Rigidbody2D.GetRelativeVector", "Get a global space vector given the vector relativeVector in rigidBody local space." },
{ "Rigidbody2D.GetVector", "Get a local space vector given the vector vector in rigidBody global space." },
{ "Rigidbody2D.IsAwake", "Is the rigidbody \"awake\"?" },
{ "Rigidbody2D.IsSleeping", "Is the rigidbody \"sleeping\"?" },
{ "Rigidbody2D.MovePosition", "Moves the rigidbody to position." },
{ "Rigidbody2D.MoveRotation", "Rotates the rigidbody to angle." },
{ "Rigidbody2D.Sleep", "Make the rigidbody \"sleep\"." },
{ "Rigidbody2D.WakeUp", "Disables the \"sleeping\" state of a rigidbody." },
{ "RigidbodyConstraints", "Use these flags to constrain motion of Rigidbodies." },
{ "RigidbodyConstraints.FreezeAll", "Freeze rotation and motion along all axes." },
{ "RigidbodyConstraints.FreezePosition", "Freeze motion along all axes." },
{ "RigidbodyConstraints.FreezePositionX", "Freeze motion along the X-axis." },
{ "RigidbodyConstraints.FreezePositionY", "Freeze motion along the Y-axis." },
{ "RigidbodyConstraints.FreezePositionZ", "Freeze motion along the Z-axis." },
{ "RigidbodyConstraints.FreezeRotation", "Freeze rotation along all axes." },
{ "RigidbodyConstraints.FreezeRotationX", "Freeze rotation along the X-axis." },
{ "RigidbodyConstraints.FreezeRotationY", "Freeze rotation along the Y-axis." },
{ "RigidbodyConstraints.FreezeRotationZ", "Freeze rotation along the Z-axis." },
{ "RigidbodyConstraints.None", "No constraints." },
{ "RigidbodyInterpolation", "Rigidbody interpolation mode." },
{ "RigidbodyInterpolation.Extrapolate", "Extrapolation will predict the position of the rigidbody based on the current velocity." },
{ "RigidbodyInterpolation.Interpolate", "Interpolation will always lag a little bit behind but can be smoother than extrapolation." },
{ "RigidbodyInterpolation.None", "No Interpolation." },
{ "RigidbodyInterpolation2D", "Interpolation mode for Rigidbody2D objects." },
{ "RigidbodyInterpolation2D.Extrapolate", "Smooth an object's movement based on an estimate of its position in the next frame." },
{ "RigidbodyInterpolation2D.Interpolate", "Smooth movement based on the object's positions in previous frames." },
{ "RigidbodyInterpolation2D.None", "Do not apply any smoothing to the object's movement." },
{ "RigidbodySleepMode2D", "Settings for a Rigidbody2D's initial sleep state." },
{ "RigidbodySleepMode2D.NeverSleep", "Rigidbody2D never automatically sleeps." },
{ "RigidbodySleepMode2D.StartAsleep", "Rigidbody2D is initially asleep." },
{ "RigidbodySleepMode2D.StartAwake", "Rigidbody2D is initially awake." },
{ "RotationDriveMode", "Control ConfigurableJoint's rotation with either X & YZ or Slerp Drive." },
{ "RotationDriveMode.Slerp", "Use Slerp drive." },
{ "RotationDriveMode.XYAndZ", "Use XY & Z Drive." },
{ "RPC", "Attribute for setting up RPC functions." },
{ "RPCMode", "Option for who will receive an RPC, used by NetworkView.RPC." },
{ "RPCMode.All", "Sends to everyone." },
{ "RPCMode.AllBuffered", "Sends to everyone and adds to the buffer." },
{ "RPCMode.Others", "Sends to everyone except the sender." },
{ "RPCMode.OthersBuffered", "Sends to everyone except the sender and adds to the buffer." },
{ "RPCMode.Server", "Sends to the server only." },
{ "RuntimeAnimatorController", "Runtime reprentation of the AnimatorController. It can be used to change the Animator's AnimationSource during runtime." },
{ "RuntimePlatform", "The platform application is running. Returned by Application.platform." },
{ "RuntimePlatform.Android", "In the player on Android devices." },
{ "RuntimePlatform.FlashPlayer", "Flash Player." },
{ "RuntimePlatform.IPhonePlayer", "In the player on the iPhone." },
{ "RuntimePlatform.LinuxPlayer", "In the player on Linux." },
{ "RuntimePlatform.OSXDashboardPlayer", "In the Dashboard widget on Mac OS X." },
{ "RuntimePlatform.OSXEditor", "In the Unity editor on Mac OS X." },
{ "RuntimePlatform.OSXPlayer", "In the player on Mac OS X." },
{ "RuntimePlatform.OSXWebPlayer", "In the web player on Mac OS X." },
{ "RuntimePlatform.PS3", "In the player on the Play Station 3." },
{ "RuntimePlatform.PS4", "In the player on the Playstation 4." },
{ "RuntimePlatform.PSMPlayer", "In the player on the PSM." },
{ "RuntimePlatform.PSP2", "In the player on the PS Vita." },
{ "RuntimePlatform.SamsungTVPlayer", "In the player on Samsung Smart TV." },
{ "RuntimePlatform.WindowsEditor", "In the Unity editor on Windows." },
{ "RuntimePlatform.WindowsPlayer", "In the player on Windows." },
{ "RuntimePlatform.WindowsWebPlayer", "In the web player on Windows." },
{ "RuntimePlatform.WP8Player", "In the player on Windows Phone 8 device." },
{ "RuntimePlatform.XBOX360", "In the player on the XBOX360." },
{ "RuntimePlatform.XboxOne", "In the player on Xbox One." },
{ "SamsungTV", "Interace into SamsungTV specific functionality." },
{ "SamsungTV-touchPadMode", "The type of input the remote's touch pad produces." },
{ "SamsungTV.TouchPadMode", "Types of input the remote's touchpad can produce." },
{ "SamsungTV.TouchPadMode.Dpad", "Swipe in a direction to get an arrow key event." },
{ "SamsungTV.TouchPadMode.Joystick", "Touchpad works like an analog joystick." },
{ "SamsungTV.TouchPadMode.Mouse", "Touchpad controls a mouse cursor like a laptop's touchpad." },
{ "ScaleMode", "Scaling mode to draw textures with." },
{ "ScaleMode.ScaleAndCrop", "Scales the texture, maintaining aspect ratio, so it completely covers the position rectangle passed to GUI.DrawTexture. If the texture is being draw to a rectangle with a different aspect ratio than the original, the image is cropped." },
{ "ScaleMode.ScaleToFit", "Scales the texture, maintaining aspect ratio, so it completely fits withing the position rectangle passed to GUI.DrawTexture." },
{ "ScaleMode.StretchToFill", "Stretches the texture to fill the complete rectangle passed in to GUI.DrawTexture." },
{ "SCEBuildSubtarget", "Target PS3 or PS4 build type." },
{ "SCEBuildSubtarget.BluRayTitle", "Build a package suited for BluRay Submission." },
{ "SCEBuildSubtarget.HddTitle", "Build a package suited for DLC Submission." },
{ "SCEBuildSubtarget.PCHosted", "Build package that it's hosted on the PC." },
{ "Screen", "Access to display information." },
{ "Screen-autorotateToLandscapeLeft", "Allow auto-rotation to landscape left?" },
{ "Screen-autorotateToLandscapeRight", "Allow auto-rotation to landscape right?" },
{ "Screen-autorotateToPortrait", "Allow auto-rotation to portrait?" },
{ "Screen-autorotateToPortraitUpsideDown", "Allow auto-rotation to portrait, upside down?" },
{ "Screen-currentResolution", "The current screen resolution (Read Only)." },
{ "Screen-dpi", "The current DPI of the screen / device (Read Only)." },
{ "Screen-fullScreen", "Is the game running fullscreen?" },
{ "Screen-height", "The current height of the screen window in pixels (Read Only)." },
{ "Screen-lockCursor", "Should the cursor be locked?" },
{ "Screen-orientation", "Specifies logical orientation of the screen." },
{ "Screen-resolutions", "All fullscreen resolutions supported by the monitor (Read Only)." },
{ "Screen-showCursor", "Should the cursor be visible?" },
{ "Screen-sleepTimeout", "A power saving setting, allowing the screen to dim some time after the last active user interaction." },
{ "Screen-width", "The current width of the screen window in pixels (Read Only)." },
{ "Screen.SetResolution", "Switches the screen resolution." },
{ "ScreenOrientation", "Describes screen orientation." },
{ "ScreenOrientation.AutoRotation", "Auto-rotates the screen as necessary toward any of the enabled orientations." },
{ "ScreenOrientation.LandscapeLeft", "Landscape orientation, counter-clockwise from the portrait orientation." },
{ "ScreenOrientation.LandscapeRight", "Landscape orientation, clockwise from the portrait orientation." },
{ "ScreenOrientation.Portrait", "Portrait orientation." },
{ "ScreenOrientation.PortraitUpsideDown", "Portrait orientation, upside down." },
{ "ScriptableObject", "A class you can derive from if you want to create objects that don't need to be attached to game objects." },
{ "ScriptableObject.CreateInstance", "Creates an instance of a scriptable object with className." },
{ "ScriptableObject.OnDestroy", "This function is called when the scriptable object will be destroyed." },
{ "ScriptableObject.OnDisable", "This function is called when the scriptable object goes out of scope." },
{ "ScriptableObject.OnEnable", "This function is called when the object is loaded." },
{ "ScriptableWizard", "Derive from this class to create an editor wizard." },
{ "ScriptableWizard-errorString", "Allows you to set the error text of the wizard." },
{ "ScriptableWizard-helpString", "Allows you to set the help text of the wizard." },
{ "ScriptableWizard-isValid", "Allows you to enable and disable the wizard create button, so that the user can not click it." },
{ "ScriptableWizard.DisplayWizard", "Creates a wizard." },
{ "ScriptableWizard.OnDrawGizmos", "Called every frame when the wizard is visible." },
{ "ScriptableWizard.OnWizardCreate", "This is called when the user clicks on the Create button." },
{ "ScriptableWizard.OnWizardOtherButton", "Allows you to provide an action when the user clicks on the other button." },
{ "ScriptableWizard.OnWizardUpdate", "This is called when the wizard is opened or whenever the user changes something in the wizard." },
{ "ScriptCallOptimizationLevel", "Script call optimization level." },
{ "ScriptCallOptimizationLevel.FastButNoExceptions", "Script method call overhead decreased at the expense of limited compatibility." },
{ "ScriptCallOptimizationLevel.SlowAndSafe", "Default setting." },
{ "Security", "Webplayer security related class." },
{ "Security.PrefetchSocketPolicy", "Prefetch the webplayer socket security policy from a non-default port number." },
{ "Selection", "Access to the selection in the editor." },
{ "Selection-activeGameObject", "Returns the active game object. (The one shown in the inspector)." },
{ "Selection-activeInstanceID", "Returns the instanceID of the actual object selection. Includes prefabs, non-modifyable objects." },
{ "Selection-activeObject", "Returns the actual object selection. Includes prefabs, non-modifyable objects." },
{ "Selection-activeTransform", "Returns the active transform. (The one shown in the inspector)." },
{ "Selection-assetGUIDs", "Returns the guids of the selected assets." },
{ "Selection-gameObjects", "Returns the actual game object selection. Includes prefabs, non-modifyable objects." },
{ "Selection-instanceIDs", "The actual unfiltered selection from the Scene returned as instance ids instead of Selection.objects." },
{ "Selection-objects", "The actual unfiltered selection from the Scene." },
{ "Selection-transforms", "Returns the top level selection, excluding prefabs." },
{ "Selection.Contains", "Returns whether an object is contained in the current selection." },
{ "Selection.GetFiltered", "Returns the current selection filtered by type and mode." },
{ "Selection.GetTransforms", "Allows for fine grained control of the selection type using the SelectionMode bitmask." },
{ "SelectionBaseAttribute", "Add this attribute to a script class to mark its GameObject as a selection base object for Scene View picking." },
{ "SelectionMode", "SelectionMode can be used to tweak the selection returned by Selection.GetTransforms." },
{ "SelectionMode.Assets", "Only return objects that are assets in the Asset directory." },
{ "SelectionMode.Deep", "Return the selection and all child transforms of the selection." },
{ "SelectionMode.DeepAssets", "If the selection contains folders, also include all assets and subfolders within that folder in the file hierarchy." },
{ "SelectionMode.Editable", "Excludes any objects which shall not be modified." },
{ "SelectionMode.ExcludePrefab", "Excludes any prefabs from the selection." },
{ "SelectionMode.TopLevel", "Only return the topmost selected transform. A selected child of another selected transform will be filtered out." },
{ "SelectionMode.Unfiltered", "Return the whole selection." },
{ "SendMessageOptions", "Options for how to send a message." },
{ "SendMessageOptions.DontRequireReceiver", "No receiver is required for SendMessage." },
{ "SendMessageOptions.RequireReceiver", "A receiver is required for SendMessage." },
{ "Serializable", "The Serializable attribute lets you embed a class with sub properties in the inspector." },
{ "SerializedObject", "SerializedObject and SerializedProperty are classes for editing properties on objects in a completely generic way that automatically handles undo and styling UI for prefabs." },
{ "SerializedObject-ctor", "Create SerializedObject for inspected object." },
{ "SerializedObject-isEditingMultipleObjects", "Does the serialized object represents multiple objects due to multi-object editing? (Read Only)" },
{ "SerializedObject-targetObject", "The inspected object (Read Only)." },
{ "SerializedObject-targetObjects", "The inspected objects (Read Only)." },
{ "SerializedObject.ApplyModifiedProperties", "Apply property modifications." },
{ "SerializedObject.CopyFromSerializedProperty", "Copies a value from a SerializedProperty to the same serialized property on this serialized object." },
{ "SerializedObject.FindProperty", "Find serialized property by name." },
{ "SerializedObject.GetIterator", "Get the first serialized property." },
{ "SerializedObject.SetIsDifferentCacheDirty", "Update hasMultipleDifferentValues cache on the next /Update()/ call." },
{ "SerializedObject.Update", "Update serialized object's representation." },
{ "SerializedObject.UpdateIfDirtyOrScript", "Update serialized object's representation, only if the object has been modified since the last call to Update or if it is a script." },
{ "SerializedProperty", "SerializedProperty and SerializedObject are classes for editing properties on objects in a completely generic way that automatically handles undo and styling UI for prefabs." },
{ "SerializedProperty-animationCurveValue", "Value of a animation curve property." },
{ "SerializedProperty-arraySize", "The number of elements in the array. If the SerializedObject contains multiple objects it will return the smallest number of elements. So it is always possible to iterate through the SerializedObject and only get properties found in all objects." },
{ "SerializedProperty-boolValue", "Value of a boolean property." },
{ "SerializedProperty-boundsValue", "Value of bounds property." },
{ "SerializedProperty-colorValue", "Value of a color property." },
{ "SerializedProperty-depth", "Nesting depth of the property. (Read Only)" },
{ "SerializedProperty-editable", "Is this property editable? (Read Only)" },
{ "SerializedProperty-enumNames", "Names of enumeration of an enum property." },
{ "SerializedProperty-enumValueIndex", "Enum index of an enum property." },
{ "SerializedProperty-floatValue", "Value of a float property." },
{ "SerializedProperty-hasChildren", "Does it have child properties? (Read Only)" },
{ "SerializedProperty-hasMultipleDifferentValues", "Does this property represent multiple different values due to multi-object editing? (Read Only)" },
{ "SerializedProperty-hasVisibleChildren", "Does it have visible child properties? (Read Only)" },
{ "SerializedProperty-intValue", "Value of an integer property." },
{ "SerializedProperty-isArray", "Is this property an array? (Read Only)" },
{ "SerializedProperty-isExpanded", "Is this property expanded in the inspector?" },
{ "SerializedProperty-isInstantiatedPrefab", "Is property part of a prefab instance? (Read Only)" },
{ "SerializedProperty-name", "Name of the property. (Read Only)" },
{ "SerializedProperty-objectReferenceValue", "Value of an object reference property." },
{ "SerializedProperty-prefabOverride", "Is property's value different from the prefab it belongs to?" },
{ "SerializedProperty-propertyPath", "Full path of the property. (Read Only)" },
{ "SerializedProperty-propertyType", "Type of this property (Read Only)." },
{ "SerializedProperty-quaternionValue", "Value of a quaternion property." },
{ "SerializedProperty-rectValue", "Value of a rectangle property." },
{ "SerializedProperty-serializedObject", "SerializedObject this property belongs to (Read Only)." },
{ "SerializedProperty-stringValue", "Value of a string property." },
{ "SerializedProperty-tooltip", "Tooltip of the property. (Read Only)" },
{ "SerializedProperty-type", "Type name of the property. (Read Only)" },
{ "SerializedProperty-vector2Value", "Value of a 2D vector property." },
{ "SerializedProperty-vector3Value", "Value of a 3D vector property." },
{ "SerializedProperty-vector4Value", "Value of a 4D vector property." },
{ "SerializedProperty.ClearArray", "Remove all elements from the array." },
{ "SerializedProperty.Copy", "Returns a copy of the SerializedProperty iterator in its current state. This is useful if you want to keep a reference to the current property but continue with the iteration." },
{ "SerializedProperty.CountInProperty", "Count visible children of this property, including this property itself." },
{ "SerializedProperty.CountRemaining", "Count remaining visible properties." },
{ "SerializedProperty.DeleteArrayElementAtIndex", "Delete the element at the specified index in the array." },
{ "SerializedProperty.DeleteCommand", "Deletes the serialized property." },
{ "SerializedProperty.DuplicateCommand", "Duplicates the serialized property." },
{ "SerializedProperty.EqualContents", "See if contained serialized properties are equal." },
{ "SerializedProperty.FindPropertyRelative", "Retrieves the SerializedProperty at a relative path to the current property." },
{ "SerializedProperty.GetArrayElementAtIndex", "Returns the element at the specified index in the array." },
{ "SerializedProperty.GetEndProperty", "Retrieves the SerializedProperty that defines the end range of this property." },
{ "SerializedProperty.GetEnumerator", "Retrieves an iterator that allows you to iterator over the current nexting of a serialized property." },
{ "SerializedProperty.InsertArrayElementAtIndex", "Insert an empty element at the specified index in the array." },
{ "SerializedProperty.MoveArrayElement", "Move an array element from srcIndex to dstIndex." },
{ "SerializedProperty.Next", "Move to next property." },
{ "SerializedProperty.NextVisible", "Move to next visible property." },
{ "SerializedProperty.Reset", "Move to first property of the object." },
{ "SerializedPropertyType", "Type of a SerializedProperty." },
{ "SerializedPropertyType.AnimationCurve", "AnimationCurve property." },
{ "SerializedPropertyType.ArraySize", "Array size property." },
{ "SerializedPropertyType.Boolean", "Boolean property." },
{ "SerializedPropertyType.Bounds", "Bounds property." },
{ "SerializedPropertyType.Character", "Character property." },
{ "SerializedPropertyType.Color", "Color property." },
{ "SerializedPropertyType.Enum", "Enumeration property." },
{ "SerializedPropertyType.Float", "Float property." },
{ "SerializedPropertyType.Gradient", "Gradient property." },
{ "SerializedPropertyType.Integer", "Integer property." },
{ "SerializedPropertyType.LayerMask", "LayerMask property." },
{ "SerializedPropertyType.ObjectReference", "Reference to another object." },
{ "SerializedPropertyType.Rect", "Rectangle property." },
{ "SerializedPropertyType.String", "String property." },
{ "SerializedPropertyType.Vector2", "2D vector property." },
{ "SerializedPropertyType.Vector3", "3D vector property." },
{ "SerializedPropertyType.Vector4", "4D vector property." },
{ "SerializeField", "Force Unity to serialize a private field." },
{ "Shader", "Shader scripts used for all rendering." },
{ "Shader-globalMaximumLOD", "Shader LOD level for all shaders." },
{ "Shader-isSupported", "Can this shader run on the end-users graphics card? (Read Only)" },
{ "Shader-maximumLOD", "Shader LOD level for this shader." },
{ "Shader-renderQueue", "Render queue of this shader. (Read Only)" },
{ "Shader.Find", "Finds a shader with the given name." },
{ "Shader.PropertyToID", "Gets unique identifier for a shader property name." },
{ "Shader.SetGlobalBuffer", "Sets a global compute buffer property for all shaders." },
{ "Shader.SetGlobalColor", "Sets a global color property for all shaders." },
{ "Shader.SetGlobalFloat", "Sets a global float property for all shaders." },
{ "Shader.SetGlobalInt", "Sets a global int property for all shaders." },
{ "Shader.SetGlobalMatrix", "Sets a global matrix property for all shaders." },
{ "Shader.SetGlobalTexture", "Sets a global texture property for all shaders." },
{ "Shader.SetGlobalVector", "Sets a global vector property for all shaders." },
{ "Shader.WarmupAllShaders", "Fully load all shaders to prevent future performance hiccups." },
{ "ShaderUtil", "Utility functions to assist with working with shaders from the editor." },
{ "ShaderUtil-hardwareSupportsRectRenderTexture", "Does the current hardware support render textues." },
{ "ShaderUtil.GetPropertyCount", "Get the number of properties in Shader s." },
{ "ShaderUtil.GetPropertyDescription", "Get the description of the shader propery at index propertyIdx of Shader s." },
{ "ShaderUtil.GetPropertyName", "Get the name of the shader propery at index propertyIdx of Shader s." },
{ "ShaderUtil.GetPropertyType", "Get the ShaderProperyType of the shader propery at index propertyIdx of Shader s." },
{ "ShaderUtil.GetRangeLimits", "Get Limits for a range property at index propertyIdx of Shader s." },
{ "ShaderUtil.GetTexDim", "Gets the ShaderPropertyTexDim of the texture at property index propertyIdx of Shader s." },
{ "ShaderUtil.IsShaderPropertyHidden", "Is the shader propery at index propertyIdx of Shader s hidden?" },
{ "ShaderUtil.ShaderPropertyTexDim", "Representation of the texture dimensions." },
{ "ShaderUtil.ShaderPropertyTexDim.TexDim2D", "2D Texture." },
{ "ShaderUtil.ShaderPropertyTexDim.TexDim3D", "3D Texture." },
{ "ShaderUtil.ShaderPropertyTexDim.TexDimAny", "Any texture dimension (catch all)." },
{ "ShaderUtil.ShaderPropertyTexDim.TexDimCUBE", "Texure Cube (Cubemap)." },
{ "ShaderUtil.ShaderPropertyTexDim.TexDimRECT", "Texture Rect." },
{ "ShaderUtil.ShaderPropertyTexDim.TexDimUnknown", "Unknown Texture dimension." },
{ "ShaderUtil.ShaderPropertyType", "Type of a given texture property." },
{ "ShaderUtil.ShaderPropertyType.Color", "Color Property." },
{ "ShaderUtil.ShaderPropertyType.Float", "Float Property." },
{ "ShaderUtil.ShaderPropertyType.Range", "Range Property." },
{ "ShaderUtil.ShaderPropertyType.TexEnv", "Texture Property." },
{ "ShaderUtil.ShaderPropertyType.Vector", "Vector Property." },
{ "ShadowProjection", "Shadow projection type for Quality Settings." },
{ "ShadowProjection.CloseFit", "Close fit shadow maps with linear fadeout." },
{ "ShadowProjection.StableFit", "Stable shadow maps with spherical fadeout." },
{ "SkeletonBone", "Details of the Transform name mapped to a model's skeleton bone and its default position and rotation in the T-pose." },
{ "SkeletonBone-name", "The name of the Transform mapped to the bone." },
{ "SkeletonBone-position", "The T-pose position of the bone in local space." },
{ "SkeletonBone-rotation", "The T-pose rotation of the bone in local space." },
{ "SkeletonBone-scale", "The T-pose scaling of the bone in local space." },
{ "SkinnedCloth", "The SkinnedCloth component works together with the SkinnedMeshRenderer to simulate clothing on a character." },
{ "SkinnedCloth-coefficients", "The cloth skinning coefficients used to set up how the cloth interacts with the skinned mesh." },
{ "SkinnedCloth-worldAccelerationScale", "How much world-space acceleration of the character will affect cloth vertices." },
{ "SkinnedCloth-worldVelocityScale", "How much world-space movement of the character will affect cloth vertices." },
{ "SkinnedCloth.SetEnabledFading", "Fade the cloth simulation in or out, and enabled or disable the SkinnedCloth." },
{ "SkinnedMeshRenderer", "The Skinned Mesh filter." },
{ "SkinnedMeshRenderer-bones", "The bones used to skin the mesh." },
{ "SkinnedMeshRenderer-localBounds", "AABB of this Skinned Mesh in its local space." },
{ "SkinnedMeshRenderer-quality", "The maximum number of bones affecting a single vertex." },
{ "SkinnedMeshRenderer-sharedMesh", "The mesh used for skinning." },
{ "SkinnedMeshRenderer-updateWhenOffscreen", "If enabled, the Skinned Mesh will be updated when offscreen. If disabled, this also disables updating animations." },
{ "SkinnedMeshRenderer.BakeMesh", "Creates a snapshot of SkinnedMeshRenderer and stores it in mesh." },
{ "SkinnedMeshRenderer.GetBlendShapeWeight", "Returns weight of BlendShape on this renderer." },
{ "SkinnedMeshRenderer.SetBlendShapeWeight", "Sets weight of BlendShape on this renderer." },
{ "SkinQuality", "The maximum number of bones affecting a single vertex." },
{ "SkinQuality.Auto", "Chooses the number of bones from the number current QualitySettings. (Default)" },
{ "SkinQuality.Bone1", "Use only 1 bone to deform a single vertex. (The most important bone will be used)." },
{ "SkinQuality.Bone2", "Use 2 bones to deform a single vertex. (The most important bones will be used)." },
{ "SkinQuality.Bone4", "Use 4 bones to deform a single vertex." },
{ "Skybox", "A script interface for the skybox component." },
{ "Skybox-material", "The material used by the skybox." },
{ "SleepTimeout", "Constants for special values of Screen.sleepTimeout." },
{ "SleepTimeout.NeverSleep", "Prevent screen dimming." },
{ "SleepTimeout.SystemSetting", "Set the sleep timeout to whatever user has specified in the system settings." },
{ "SliderJoint2D", "Joint that restricts the motion of a Rigidbody2D object to a single line." },
{ "SliderJoint2D-angle", "The angle of the line in space." },
{ "SliderJoint2D-jointSpeed", "The current joint speed." },
{ "SliderJoint2D-jointTranslation", "The current joint translation." },
{ "SliderJoint2D-limits", "Restrictions on how far the joint can slide in each direction along the line." },
{ "SliderJoint2D-limitState", "Gets the state of the joint limit." },
{ "SliderJoint2D-motor", "Parameters for a motor force that is applied automatically to the Rigibody2D along the line." },
{ "SliderJoint2D-referenceAngle", "The angle referenced between the two bodies used as the constraint for the joint." },
{ "SliderJoint2D-useLimits", "Should motion limits be used?" },
{ "SliderJoint2D-useMotor", "Should a motor force be applied automatically to the Rigidbody2D?" },
{ "SliderJoint2D.GetMotorForce", "Gets the motor force of the joint given the specified timestep." },
{ "Social", "Generic access to the Social API." },
{ "Social-localUser", "The local user (potentially not logged in)." },
{ "Social.Active", "This is the currently active social platform." },
{ "Social.CreateAchievement", "Create an IAchievement instance." },
{ "Social.CreateLeaderboard", "Create an ILeaderboard instance." },
{ "Social.LoadAchievementDescriptions", "Loads the achievement descriptions accociated with this application." },
{ "Social.LoadAchievements", "Load the achievements the logged in user has already achieved or reported progress on." },
{ "Social.LoadScores", "Load a default set of scores from the given leaderboard." },
{ "Social.LoadUsers", "Load the user profiles accociated with the given array of user IDs." },
{ "Social.ReportProgress", "Reports the progress of an achievement." },
{ "Social.ReportScore", "Report a score to a specific leaderboard." },
{ "Social.ShowAchievementsUI", "Show a default/system view of the games achievements." },
{ "Social.ShowLeaderboardUI", "Show a default/system view of the games leaderboards." },
{ "SocialPlatforms.GameCenter.GameCenterPlatform", "iOS GameCenter implementation for network services." },
{ "SocialPlatforms.GameCenter.GameCenterPlatform.ResetAllAchievements", "Reset all the achievements for the local user." },
{ "SocialPlatforms.GameCenter.GameCenterPlatform.ShowDefaultAchievementCompletionBanner", "Show the default iOS banner when achievements are completed." },
{ "SocialPlatforms.GameCenter.GameCenterPlatform.ShowLeaderboardUI", "Show the leaderboard UI with a specific leaderboard shown initially with a specific time scope selected." },
{ "SocialPlatforms.IAchievement", "Information for a users achievement." },
{ "SocialPlatforms.IAchievement-completed", "Set to true when percentCompleted is 100.0." },
{ "SocialPlatforms.IAchievement-hidden", "This achievement is currently hidden from the user." },
{ "SocialPlatforms.IAchievement-id", "The unique identifier of this achievement." },
{ "SocialPlatforms.IAchievement-lastReportedDate", "Set by server when percentCompleted is updated." },
{ "SocialPlatforms.IAchievement-percentCompleted", "Progress for this achievement." },
{ "SocialPlatforms.IAchievement.ReportProgress", "Send notification about progress on this achievement." },
{ "SocialPlatforms.IAchievementDescription", "Static data describing an achievement." },
{ "SocialPlatforms.IAchievementDescription-achievedDescription", "Description when the achivement is completed." },
{ "SocialPlatforms.IAchievementDescription-hidden", "Hidden achievement are not shown in the list until the percentCompleted has been touched (even if it's 0.0)." },
{ "SocialPlatforms.IAchievementDescription-id", "Unique identifier for this achievement description." },
{ "SocialPlatforms.IAchievementDescription-image", "Image representation of the achievement." },
{ "SocialPlatforms.IAchievementDescription-points", "Point value of this achievement." },
{ "SocialPlatforms.IAchievementDescription-title", "Human readable title." },
{ "SocialPlatforms.IAchievementDescription-unachievedDescription", "Description when the achivement has not been completed." },
{ "SocialPlatforms.ILeaderboard", "The leaderboard contains the scores of all players for a particular game." },
{ "SocialPlatforms.ILeaderboard-id", "Unique identifier for this leaderboard." },
{ "SocialPlatforms.ILeaderboard-loading", "The leaderboad is in the process of loading scores." },
{ "SocialPlatforms.ILeaderboard-localUserScore", "The leaderboard score of the logged in user." },
{ "SocialPlatforms.ILeaderboard-maxRange", "The total amount of scores the leaderboard contains." },
{ "SocialPlatforms.ILeaderboard-range", "The rank range this leaderboard returns." },
{ "SocialPlatforms.ILeaderboard-scores", "The leaderboard scores returned by a query." },
{ "SocialPlatforms.ILeaderboard-timeScope", "The time period/scope searched by this leaderboard." },
{ "SocialPlatforms.ILeaderboard-title", "The human readable title of this leaderboard." },
{ "SocialPlatforms.ILeaderboard-userScope", "The users scope searched by this leaderboard." },
{ "SocialPlatforms.ILeaderboard.LoadScores", "Load scores according to the filters set on this leaderboard." },
{ "SocialPlatforms.ILeaderboard.SetUserFilter", "Only search for these user IDs." },
{ "SocialPlatforms.ILocalUser", "Represents the local or currently logged in user." },
{ "SocialPlatforms.ILocalUser-authenticated", "Checks if the current user has been authenticated." },
{ "SocialPlatforms.ILocalUser-friends", "The users friends list." },
{ "SocialPlatforms.ILocalUser-underage", "Is the user underage?" },
{ "SocialPlatforms.ILocalUser.Authenticate", "Authenticate the local user to the current active Social API implementation and fetch his profile data." },
{ "SocialPlatforms.ILocalUser.LoadFriends", "Fetches the friends list of the logged in user. The friends list on the Social.localUser instance is populated if this call succeeds." },
{ "SocialPlatforms.IScore", "A game score." },
{ "SocialPlatforms.IScore-date", "The date the score was achieved." },
{ "SocialPlatforms.IScore-formattedValue", "The correctly formatted value of the score, like X points or X kills." },
{ "SocialPlatforms.IScore-leaderboardID", "The ID of the leaderboard this score belongs to." },
{ "SocialPlatforms.IScore-rank", "The rank or position of the score in the leaderboard." },
{ "SocialPlatforms.IScore-userID", "The user who owns this score." },
{ "SocialPlatforms.IScore-value", "The score value achieved." },
{ "SocialPlatforms.IScore.ReportScore", "Report this score instance." },
{ "SocialPlatforms.ISocialPlatform", "The generic Social API interface which implementations must inherit." },
{ "SocialPlatforms.ISocialPlatform-localUser", "See Social.localUser." },
{ "SocialPlatforms.ISocialPlatform.CreateAchievement", "See Social.CreateAchievement." },
{ "SocialPlatforms.ISocialPlatform.CreateLeaderboard", "See Social.CreateLeaderboard." },
{ "SocialPlatforms.ISocialPlatform.LoadAchievementDescriptions", "See Social.LoadAchievementDescriptions." },
{ "SocialPlatforms.ISocialPlatform.LoadAchievements", "See Social.LoadAchievements." },
{ "SocialPlatforms.ISocialPlatform.LoadScores", "See Social.LoadScores." },
{ "SocialPlatforms.ISocialPlatform.LoadUsers", "See Social.LoadUsers." },
{ "SocialPlatforms.ISocialPlatform.ReportProgress", "See Social.ReportProgress." },
{ "SocialPlatforms.ISocialPlatform.ReportScore", "See Social.ReportScore." },
{ "SocialPlatforms.ISocialPlatform.ShowAchievementsUI", "See Social.ShowAchievementsUI." },
{ "SocialPlatforms.ISocialPlatform.ShowLeaderboardUI", "See Social.ShowLeaderboardUI." },
{ "SocialPlatforms.IUserProfile", "Represents generic user instances, like friends of the local user." },
{ "SocialPlatforms.IUserProfile-id", "This users unique identifier." },
{ "SocialPlatforms.IUserProfile-image", "Avatar image of the user." },
{ "SocialPlatforms.IUserProfile-isFriend", "Is this user a friend of the current logged in user?" },
{ "SocialPlatforms.IUserProfile-state", "Presence state of the user." },
{ "SocialPlatforms.IUserProfile-userName", "This user's username or alias." },
{ "SocialPlatforms.Local.ShowLeaderboardUI", "Show a default/system view of the games leaderboards." },
{ "SocialPlatforms.Range", "The score range a leaderboard query should include." },
{ "SocialPlatforms.Range-count", "The total amount of scores retreived." },
{ "SocialPlatforms.Range-ctor", "Constructor for a score range, the range starts from a specific value and contains a maxium score count." },
{ "SocialPlatforms.Range-from", "The rank of the first score which is returned." },
{ "SocialPlatforms.TimeScope", "The scope of time searched through when querying the leaderboard." },
{ "SocialPlatforms.UserScope", "The scope of the users searched through when querying the leaderboard." },
{ "SocialPlatforms.UserState", "User presence state." },
{ "SocialPlatforms.UserState.Offline", "The user is offline." },
{ "SocialPlatforms.UserState.Online", "The user is online." },
{ "SocialPlatforms.UserState.OnlineAndAway", "The user is online but away from his computer." },
{ "SocialPlatforms.UserState.OnlineAndBusy", "The user is only but set his status to busy." },
{ "SocialPlatforms.UserState.Playing", "The user is playing a game." },
{ "SoftJointLimit", "The limits defined by the CharacterJoint." },
{ "SoftJointLimit-bounciness", "When the joint hits the limit, it can be made to bounce off it." },
{ "SoftJointLimit-damper", "If spring is greater than zero, the limit is soft." },
{ "SoftJointLimit-limit", "The limit position/angle of the joint." },
{ "SoftJointLimit-spring", "If greater than zero, the limit is soft. The spring will pull the joint back." },
{ "Space", "The coordinate space in which to operate." },
{ "Space.Self", "Applies transformation relative to the local coordinate system." },
{ "Space.World", "Applies transformation relative to the world coordinate system." },
{ "SpaceAttribute", "Use this PropertyAttribute to add some spacing in the Inspector." },
{ "SpaceAttribute-ctor", "Use this DecoratorDrawer to add some spacing in the Inspector." },
{ "SpaceAttribute-height", "The spacing in pixels." },
{ "SparseTexture", "Class for handling Sparse Textures." },
{ "SparseTexture-ctor", "Create a sparse texture." },
{ "SparseTexture-isCreated", "Is the sparse texture actually created? (Read Only)" },
{ "SparseTexture-tileHeight", "Get sparse texture tile height (Read Only)." },
{ "SparseTexture-tileWidth", "Get sparse texture tile width (Read Only)." },
{ "SparseTexture.UnloadTile", "Unload sparse texture tile." },
{ "SparseTexture.UpdateTile", "Update sparse texture tile with color values." },
{ "SparseTexture.UpdateTileRaw", "Update sparse texture tile with raw pixel values." },
{ "SphereCollider", "A sphere-shaped primitive collider." },
{ "SphereCollider-center", "The center of the sphere, measured in the object's local space." },
{ "SphereCollider-radius", "The radius of the sphere, measured in the object's local space." },
{ "SplatPrototype", "A Splat prototype is just a texture that is used by the TerrainData." },
{ "SplatPrototype-normalMap", "Normal map of the splat applied to the Terrain." },
{ "SplatPrototype-texture", "Texture of the splat applied to the Terrain." },
{ "SplatPrototype-tileOffset", "Offset of the tile texture of the SplatPrototype." },
{ "SplatPrototype-tileSize", "Size of the tile used in the texture of the SplatPrototype." },
{ "SpringJoint", "The spring joint ties together 2 rigid bodies, spring forces will be automatically applied to keep the object at the given distance." },
{ "SpringJoint-damper", "The damper force used to dampen the spring force." },
{ "SpringJoint-maxDistance", "The maximum distance between the bodies relative to their initial distance." },
{ "SpringJoint-minDistance", "The minimum distance between the bodies relative to their initial distance." },
{ "SpringJoint-spring", "The spring force used to keep the two objects together." },
{ "SpringJoint2D", "Joint that attempts to keep two Rigidbody2D objects a set distance apart by applying a force between them." },
{ "SpringJoint2D-dampingRatio", "The amount by which the spring force is reduced in proportion to the movement speed." },
{ "SpringJoint2D-distance", "The distance the spring will try to keep between the two objects." },
{ "SpringJoint2D-frequency", "The frequency at which the spring oscillates around the distance distance between the objects." },
{ "SpringJoint2D.GetReactionForce", "Gets the reaction force of the joint given the specified timestep." },
{ "SpringJoint2D.GetReactionTorque", "Gets the reaction torque of the joint given the specified timestep." },
{ "Sprite", "Represents a Sprite object for use in 2D gameplay." },
{ "Sprite-border", "Returns the border sizes of the sprite." },
{ "Sprite-bounds", "Bounds of the Sprite, specified by its center and extents in world space units." },
{ "Sprite-packed", "Returns true if this Sprite is packed in an atlas." },
{ "Sprite-packingMode", "If Sprite is packed (see Sprite.packed), returns its SpritePackingMode." },
{ "Sprite-packingRotation", "If Sprite is packed (see Sprite.packed), returns its SpritePackingRotation." },
{ "Sprite-rect", "Location of the Sprite on the original Texture, specified in pixels." },
{ "Sprite-texture", "Get the reference to the used texture. If packed this will point to the atlas, if not packed will point to the source sprite." },
{ "Sprite-textureRect", "Get the rectangle this sprite uses on its texture. Raises an exception if this sprite is tightly packed in an atlas." },
{ "Sprite-textureRectOffset", "Gets the offset of the rectangle this sprite uses on its texture to the original sprite bounds. If sprite mesh type is FullRect, offset is zero." },
{ "Sprite.Create", "Create a new Sprite object." },
{ "SpriteAlignment", "How a Sprite's graphic rectangle is aligned with its pivot point." },
{ "SpriteAlignment.BottomCenter", "Pivot is at the center of the bottom edge of the graphic rectangle." },
{ "SpriteAlignment.BottomLeft", "Pivot is at the bottom left corner of the graphic rectangle." },
{ "SpriteAlignment.BottomRight", "Pivot is at the bottom right corner of the graphic rectangle." },
{ "SpriteAlignment.Center", "Pivot is at the center of the graphic rectangle." },
{ "SpriteAlignment.Custom", "Pivot is at a custom position within the graphic rectangle." },
{ "SpriteAlignment.LeftCenter", "Pivot is at the center of the left edge of the graphic rectangle." },
{ "SpriteAlignment.RightCenter", "Pivot is at the center of the right edge of the graphic rectangle." },
{ "SpriteAlignment.TopCenter", "Pivot is at the center of the top edge of the graphic rectangle." },
{ "SpriteAlignment.TopLeft", "Pivot is at the top left corner of the graphic rectangle." },
{ "SpriteAlignment.TopRight", "Pivot is at the top right corner of the graphic rectangle." },
{ "SpriteImportMode", "Texture importer modes for Sprite import." },
{ "SpriteImportMode.None", "Graphic is not a Sprite." },
{ "SpriteImportMode.Single", "Sprite is a single image section extracted automatically from the texture." },
{ "SpriteMeshType", "Defines the type of mesh generated for a sprite." },
{ "SpriteMeshType.FullRect", "Rectangle mesh equal to the user specified sprite size." },
{ "SpriteMeshType.Tight", "Tight mesh based on pixel alpha values. As many excess pixels are cropped as possible." },
{ "SpriteMetaData", "Editor data used in producing a Sprite." },
{ "SpriteMetaData-alignment", "Edge-relative alignment of the sprite graphic." },
{ "SpriteMetaData-border", "Edge border size for a sprite (in pixels)." },
{ "SpriteMetaData-name", "Name of the Sprite." },
{ "SpriteMetaData-pivot", "Pivot point of the Sprite relative to its bounding rectangle." },
{ "SpriteMetaData-rect", "Bounding rectangle of the sprite's graphic within the atlas image." },
{ "SpritePackerMode", "Sprite Packer mode for the current project." },
{ "SpritePackerMode.AlwaysOn", "Always maintain an up-to-date sprite atlas cache." },
{ "SpritePackerMode.BuildTimeOnly", "Updates sprite atlas cache when building player/bundles." },
{ "SpritePackerMode.Disabled", "Doesn't pack sprites." },
{ "SpritePackingMode", "Sprite packing modes for the Sprite Packer." },
{ "SpritePackingMode.Rectangle", "Alpha-cropped ractangle packing." },
{ "SpritePackingMode.Tight", "Tight mesh based packing." },
{ "SpritePackingRotation", "Sprite rotation modes for the Sprite Packer." },
{ "SpritePackingRotation.Any", "Any rotation." },
{ "SpritePackingRotation.None", "No rotation." },
{ "SpriteRenderer", "Renders a Sprite for 2D graphics." },
{ "SpriteRenderer-color", "Rendering color for the Sprite graphic." },
{ "SpriteRenderer-sprite", "The Sprite to render." },
{ "Sprites.AtlasSettings", "Describes the final atlas texture." },
{ "Sprites.AtlasSettings-generateMipMaps", "Should sprite atlas textures generate mip maps?" },
{ "Sprites.AtlasSettings-paddingPower", "The amount of extra padding between packed sprites." },
{ "Sprites.DataUtility", "Helper utilities for accessing Sprite data." },
{ "Sprites.DataUtility.GetInnerUV", "Inner UV's of the Sprite." },
{ "Sprites.DataUtility.GetMinSize", "Minimum width and height of the Sprite." },
{ "Sprites.DataUtility.GetOuterUV", "Outer UV's of the Sprite." },
{ "Sprites.DataUtility.GetPadding", "Return the padding on the sprite." },
{ "Sprites.DataUtility.GetSpriteIndices", "Returns the generated Sprite mesh indices." },
{ "Sprites.DataUtility.GetSpriteMesh", "Returns the generated Sprite mesh positions." },
{ "Sprites.DataUtility.GetSpriteTexture", "Returns the generated Sprite texture. If Sprite is packed, it is possible to query for both source and atlas textures." },
{ "Sprites.DataUtility.GetSpriteUVs", "Returns the generated Sprite mesh uvs." },
{ "Sprites.IPackerPolicy", "Sprite packing policy interface. Provide a custom implementation to control which Sprites go into which atlases." },
{ "Sprites.IPackerPolicy.GetVersion", "Return the version of your policy. Sprite Packer needs to know if atlas grouping logic changed." },
{ "Sprites.IPackerPolicy.OnGroupAtlases", "Implement custom atlas grouping here." },
{ "Sprites.Packer", "Sprite Packer helpers." },
{ "Sprites.Packer-atlasNames", "Array of Sprite atlas names found in the current atlas cache." },
{ "Sprites.Packer-kDefaultPolicy", "Name of the default Sprite Packer policy." },
{ "Sprites.Packer.Execution", "Sprite Packer execution mode." },
{ "Sprites.Packer.Execution.ForceRegroup", "Will always trigger IPackerPolicy.OnGroupAtlases." },
{ "Sprites.Packer.Execution.Normal", "Normal execution. Will not trigger IPackerPolicy.OnGroupAtlases unless IPackerPolicy, IPackerPolicy version or TextureImporter settings have changed." },
{ "Sprites.Packer.GetAtlasDataForSprite", "Returns atlasing data for the specified Sprite." },
{ "Sprites.Packer.GetTexturesForAtlas", "Returns all atlas textures generated for the specified atlas." },
{ "Sprites.Packer.Policies", "Available Sprite Packer policies for this project." },
{ "Sprites.Packer.RebuildAtlasCacheIfNeeded", "Rebuilds the Sprite atlas cache." },
{ "Sprites.Packer.SelectedPolicy", "The active Sprite Packer policy for this project." },
{ "Sprites.PackerJob", "Current Sprite Packer job definition." },
{ "Sprites.PackerJob.AddAtlas", "Registers a new atlas." },
{ "Sprites.PackerJob.AssignToAtlas", "Assigns a Sprite to an already registered atlas." },
{ "StaticBatchingUtility", "StaticBatchingUtility can prepare your objects to take advantage of Unity's static batching." },
{ "StaticBatchingUtility.Combine", "Combine will prepare all children of the staticBatchRoot for static batching." },
{ "StaticEditorFlags", "Static Editor Flags." },
{ "StaticEditorFlags.BatchingStatic", "Consider for static batching." },
{ "StaticEditorFlags.LightmapStatic", "Considered static for lightmapping." },
{ "StaticEditorFlags.NavigationStatic", "Considered static for navigation." },
{ "StaticEditorFlags.OccludeeStatic", "Considered static for occlusion." },
{ "StaticEditorFlags.OccluderStatic", "Considered static for occlusion." },
{ "StaticEditorFlags.OffMeshLinkGeneration", "Auto-generate OffMeshLink." },
{ "StaticOcclusionCulling", "StaticOcclusionCulling lets you perform static occlusion culling operations." },
{ "StaticOcclusionCulling-doesSceneHaveManualPortals", "Does the scene contain any occlusion portals that were added manually rather than automatically?" },
{ "StaticOcclusionCulling-isRunning", "Used to check if asynchronous generation of static occlusion culling data is still running." },
{ "StaticOcclusionCulling-umbraDataSize", "Returns the size in bytes that the PVS data is currently taking up in this scene on disk." },
{ "StaticOcclusionCulling.Cancel", "Used to cancel asynchronous generation of static occlusion culling data." },
{ "StaticOcclusionCulling.Clear", "Clears the PVS of the opened scene." },
{ "StaticOcclusionCulling.Compute", "Used to generate static occlusion culling data." },
{ "StaticOcclusionCulling.GenerateInBackground", "Used to compute static occlusion culling data asynchronously." },
{ "StaticOcclusionCullingVisualization", "Used to visualize static occlusion culling at development time in scene view." },
{ "StaticOcclusionCullingVisualization-showGeometryCulling", "If set to true, culling of geometry is enabled." },
{ "StaticOcclusionCullingVisualization-showOcclusionCulling", "If set to true, visualization of target volumes is enabled." },
{ "StaticOcclusionCullingVisualization-showPortals", "If set to true, visualization of portals is enabled." },
{ "StaticOcclusionCullingVisualization-showPreVisualization", "If set to true, the visualization lines of the PVS volumes will show all cells rather than cells after culling." },
{ "StaticOcclusionCullingVisualization-showViewVolumes", "If set to true, visualization of view volumes is enabled." },
{ "StaticOcclusionCullingVisualization-showVisibilityLines", "If set to true, visualization of portals is enabled." },
{ "String", "Represents text as a series of Unicode characters." },
{ "String.Empty", "Represents the empty string. (Read Only)" },
{ "String.Length", "Gets the number of characters in this instance (Read Only)." },
{ "StrippingLevel", "Managed code stripping level." },
{ "StrippingLevel.Disabled", "Managed code stripping is disabled." },
{ "StrippingLevel.StripAssemblies", "Unused parts of managed code are stripped away." },
{ "StrippingLevel.StripByteCode", "Managed method bodies are stripped away. AOT platforms only." },
{ "StrippingLevel.UseMicroMSCorlib", "Lightweight mscorlib version will be used at expense of limited compatibility." },
{ "SubstanceArchive", "Class for Substance Archive handling." },
{ "SubstanceImporter", "The SubstanceImporter class lets you access the imported ProceduralMaterial instances." },
{ "SubstanceImporter.CloneMaterial", "Clone an existing ProceduralMaterial instance." },
{ "SubstanceImporter.DestroyMaterial", "Destroy an existing ProceduralMaterial instance." },
{ "SubstanceImporter.GetAnimationUpdateRate", "Get the ProceduralMaterial animation update rate in millisecond." },
{ "SubstanceImporter.GetGenerateAllOutputs", "Check if the ProceduralMaterial needs to force generation of all its outputs." },
{ "SubstanceImporter.GetGenerateMipMaps", "Return true if the mipmaps are generated for this ProceduralMaterial." },
{ "SubstanceImporter.GetMaterialCount", "Get the number of ProceduralMaterial instances." },
{ "SubstanceImporter.GetMaterialOffset", "Get the material offset, which is used for all the textures that are part of this ProceduralMaterial." },
{ "SubstanceImporter.GetMaterials", "Get an array with the ProceduralMaterial instances." },
{ "SubstanceImporter.GetMaterialScale", "Get the material scale, which is used for all the textures that are part of this ProceduralMaterial." },
{ "SubstanceImporter.GetPlatformTextureSettings", "Get the import settings for a given ProceduralMaterial for a given platform (width and height, RAW/Compressed format, loading behavior)." },
{ "SubstanceImporter.GetPrototypeNames", "Get a list of the names of the ProceduralMaterial prototypes in the package." },
{ "SubstanceImporter.GetTextureAlphaSource", "Get the alpha source of the given texture in the ProceduralMaterial." },
{ "SubstanceImporter.InstantiateMaterial", "Instantiate a new ProceduralMaterial instance from a prototype." },
{ "SubstanceImporter.OnShaderModified", "After modifying the shader of a ProceduralMaterial, call this function to apply the changes to the importer." },
{ "SubstanceImporter.RenameMaterial", "Rename an existing ProceduralMaterial instance." },
{ "SubstanceImporter.ResetMaterial", "Reset the ProceduralMaterial to its default values." },
{ "SubstanceImporter.SetAnimationUpdateRate", "Set the ProceduralMaterial animation update rate in millisecond." },
{ "SubstanceImporter.SetGenerateAllOutputs", "Specify if the ProceduralMaterial needs to force generation of all its outputs." },
{ "SubstanceImporter.SetGenerateMipMaps", "Force the generation of mipmaps for this ProceduralMaterial." },
{ "SubstanceImporter.SetMaterialOffset", "Set the material offset, which is used for all the textures that are part of this ProceduralMaterial." },
{ "SubstanceImporter.SetMaterialScale", "Set the material scale, which is used for all the textures that are part of this ProceduralMaterial." },
{ "SubstanceImporter.SetPlatformTextureSettings", "Set the import settings for the input ProceduralMaterial for the input platform (width and height, RAW/Compressed format, loading behavior)." },
{ "SubstanceImporter.SetTextureAlphaSource", "Set the alpha source of the given texture in the ProceduralMaterial." },
{ "SystemInfo", "Access system information." },
{ "SystemInfo-deviceModel", "The model of the device (Read Only)." },
{ "SystemInfo-deviceName", "The user defined name of the device (Read Only)." },
{ "SystemInfo-deviceType", "Returns the kind of device the application is running on." },
{ "SystemInfo-deviceUniqueIdentifier", "A unique device identifier. It is guaranteed to be unique for every device (Read Only)." },
{ "SystemInfo-graphicsDeviceID", "The identifier code of the graphics device (Read Only)." },
{ "SystemInfo-graphicsDeviceName", "The name of the graphics device (Read Only)." },
{ "SystemInfo-graphicsDeviceVendor", "The vendor of the graphics device (Read Only)." },
{ "SystemInfo-graphicsDeviceVendorID", "The identifier code of the graphics device vendor (Read Only)." },
{ "SystemInfo-graphicsDeviceVersion", "The graphics API version supported by the graphics device (Read Only)." },
{ "SystemInfo-graphicsMemorySize", "Amount of video memory present (Read Only)." },
{ "SystemInfo-graphicsPixelFillrate", "Approximate pixel fill-rate of the graphics device (Read Only)." },
{ "SystemInfo-graphicsShaderLevel", "Graphics device shader capability level (Read Only)." },
{ "SystemInfo-npotSupport", "What NPOT (ie, non-power of two resolution) support does the GPU provide? (Read Only)" },
{ "SystemInfo-operatingSystem", "Operating system name with version (Read Only)." },
{ "SystemInfo-processorCount", "Number of processors present (Read Only)." },
{ "SystemInfo-processorType", "Processor name (Read Only)." },
{ "SystemInfo-supportedRenderTargetCount", "How many simultaneous render targets (MRTs) are supported? (Read Only)" },
{ "SystemInfo-supports3DTextures", "Are 3D (volume) textures supported? (Read Only)" },
{ "SystemInfo-supportsAccelerometer", "Is an accelerometer available on the device?" },
{ "SystemInfo-supportsComputeShaders", "Are compute shaders supported? (Read Only)" },
{ "SystemInfo-supportsGyroscope", "Is a gyroscope available on the device?" },
{ "SystemInfo-supportsImageEffects", "Are image effects supported? (Read Only)" },
{ "SystemInfo-supportsInstancing", "Is GPU draw call instancing supported? (Read Only)" },
{ "SystemInfo-supportsLocationService", "Is the device capable of reporting its location?" },
{ "SystemInfo-supportsRenderTextures", "Are render textures supported? (Read Only)" },
{ "SystemInfo-supportsRenderToCubemap", "Are cubemap render textures supported? (Read Only)" },
{ "SystemInfo-supportsShadows", "Are built-in shadows supported? (Read Only)" },
{ "SystemInfo-supportsSparseTextures", "Are sparse textures supported? (Read Only)" },
{ "SystemInfo-supportsStencil", "Is the stencil buffer supported? (Read Only)" },
{ "SystemInfo-supportsVibration", "Is the device capable of providing the user haptic feedback by vibration?" },
{ "SystemInfo-systemMemorySize", "Amount of system memory present (Read Only)." },
{ "SystemInfo.SupportsRenderTextureFormat", "Is render texture format supported?" },
{ "SystemLanguage", "The language the user's operating system is running in. Returned by Application.systemLanguage." },
{ "SystemLanguage.Afrikaans", "Afrikaans." },
{ "SystemLanguage.Arabic", "Arabic." },
{ "SystemLanguage.Basque", "Basque." },
{ "SystemLanguage.Belarusian", "Belarusian." },
{ "SystemLanguage.Bulgarian", "Bulgarian." },
{ "SystemLanguage.Catalan", "Catalan." },
{ "SystemLanguage.Chinese", "Chinese." },
{ "SystemLanguage.Czech", "Czech." },
{ "SystemLanguage.Danish", "Danish." },
{ "SystemLanguage.Dutch", "Dutch." },
{ "SystemLanguage.English", "English." },
{ "SystemLanguage.Estonian", "Estonian." },
{ "SystemLanguage.Faroese", "Faroese." },
{ "SystemLanguage.Finnish", "Finnish." },
{ "SystemLanguage.French", "French." },
{ "SystemLanguage.German", "German." },
{ "SystemLanguage.Greek", "Greek." },
{ "SystemLanguage.Hebrew", "Hebrew." },
{ "SystemLanguage.Hungarian", "Hungarian." },
{ "SystemLanguage.Icelandic", "Icelandic." },
{ "SystemLanguage.Indonesian", "Indonesian." },
{ "SystemLanguage.Italian", "Italian." },
{ "SystemLanguage.Japanese", "Japanese." },
{ "SystemLanguage.Korean", "Korean." },
{ "SystemLanguage.Latvian", "Latvian." },
{ "SystemLanguage.Lithuanian", "Lithuanian." },
{ "SystemLanguage.Norwegian", "Norwegian." },
{ "SystemLanguage.Polish", "Polish." },
{ "SystemLanguage.Portuguese", "Portuguese." },
{ "SystemLanguage.Romanian", "Romanian." },
{ "SystemLanguage.Russian", "Russian." },
{ "SystemLanguage.SerboCroatian", "Serbo-Croatian." },
{ "SystemLanguage.Slovak", "Slovak." },
{ "SystemLanguage.Slovenian", "Slovenian." },
{ "SystemLanguage.Spanish", "Spanish." },
{ "SystemLanguage.Swedish", "Swedish." },
{ "SystemLanguage.Thai", "Thai." },
{ "SystemLanguage.Turkish", "Turkish." },
{ "SystemLanguage.Ukrainian", "Ukrainian." },
{ "SystemLanguage.Unknown", "Unknown." },
{ "SystemLanguage.Vietnamese", "Vietnamese." },
{ "TargetGlesGraphics", "Target GLES graphics." },
{ "TargetGlesGraphics.Automatic", "Automatically select the graphics API level." },
{ "TargetGlesGraphics.OpenGLES_2_0", "Use OpenGL ES 2.0." },
{ "TargetGlesGraphics.OpenGLES_3_0", "Use OpenGL ES 3.0." },
{ "Terrain", "The Terrain component renders the terrain." },
{ "Terrain-activeTerrain", "The active terrain. This is a convenience function to get to the main terrain in the scene." },
{ "Terrain-activeTerrains", "The active terrains in the scene." },
{ "Terrain-basemapDistance", "Heightmap patches beyond basemap distance will use a precomputed low res basemap." },
{ "Terrain-castShadows", "Should terrain cast shadows?." },
{ "Terrain-detailObjectDensity", "Density of detail objects." },
{ "Terrain-detailObjectDistance", "Detail objects will be displayed up to this distance." },
{ "Terrain-heightmapMaximumLOD", "Lets you essentially lower the heightmap resolution used for rendering." },
{ "Terrain-heightmapPixelError", "An approximation of how many pixels the terrain will pop in the worst case when switching lod." },
{ "Terrain-lightmapIndex", "The index of the lightmap applied to this renderer." },
{ "Terrain-terrainData", "The Terrain Data that stores heightmaps, terrain textures, detail meshes and trees." },
{ "Terrain-treeBillboardDistance", "Distance from the camera where trees will be rendered as billboards only." },
{ "Terrain-treeCrossFadeLength", "Total distance delta that trees will use to transition from billboard orientation to mesh orientation." },
{ "Terrain-treeDistance", "The maximum distance at which trees are rendered." },
{ "Terrain-treeMaximumFullLODCount", "Maximum number of trees rendered at full LOD." },
{ "Terrain.AddTreeInstance", "Adds a tree instance to the terrain." },
{ "Terrain.CreateTerrainGameObject", "Creates a Terrain including collider from TerrainData." },
{ "Terrain.Flush", "Flushes any change done in the terrain so it takes effect." },
{ "Terrain.GetPosition", "Get the position of the terrain." },
{ "Terrain.SampleHeight", "Samples the height at the given position defined in world space, relative to the terrain space." },
{ "Terrain.SetNeighbors", "Lets you setup the connection between neighboring Terrains." },
{ "TerrainCollider", "A heightmap based collider." },
{ "TerrainCollider-terrainData", "The terrain that stores the heightmap." },
{ "TerrainData", "The TerrainData class stores heightmaps, detail mesh positions, tree instances, and terrain texture alpha maps." },
{ "TerrainData-alphamapHeight", "Height of the alpha map." },
{ "TerrainData-alphamapLayers", "Number of alpha map layers." },
{ "TerrainData-alphamapResolution", "Resolution of the alpha map." },
{ "TerrainData-alphamapWidth", "Width of the alpha map." },
{ "TerrainData-baseMapResolution", "Resolution of the base map used for rendering far patches on the terrain." },
{ "TerrainData-detailHeight", "Detail height of the TerrainData." },
{ "TerrainData-detailPrototypes", "Contains the detail texture/meshes that the terrain has." },
{ "TerrainData-detailResolution", "Detail Resolution of the TerrainData." },
{ "TerrainData-detailWidth", "Detail width of the TerrainData." },
{ "TerrainData-heightmapHeight", "Height of the terrain in samples (Read Only)." },
{ "TerrainData-heightmapResolution", "Resolution of the heightmap." },
{ "TerrainData-heightmapScale", "The size of each heightmap sample." },
{ "TerrainData-heightmapWidth", "Width of the terrain in samples (Read Only)." },
{ "TerrainData-physicMaterial", "The physic material used by TerrainCollider using this Terrain." },
{ "TerrainData-size", "The total size in world units of the terrain." },
{ "TerrainData-splatPrototypes", "Splat texture used by the terrain." },
{ "TerrainData-treeInstances", "Contains the current trees placed in the terrain." },
{ "TerrainData-treePrototypes", "The list of tree prototypes this are the ones available in the inspector." },
{ "TerrainData-wavingGrassAmount", "Amount of waving grass in the terrain." },
{ "TerrainData-wavingGrassSpeed", "Speed of the waving grass." },
{ "TerrainData-wavingGrassStrength", "Strength of the waving grass in the terrain." },
{ "TerrainData-wavingGrassTint", "Color of the waving grass that the terrain has." },
{ "TerrainData.GetAlphamaps", "Returns the alpha map at a position x, y given a width and height." },
{ "TerrainData.GetDetailLayer", "Returns a 2D array of the detail object density in the specific location." },
{ "TerrainData.GetHeight", "Gets the height at a certain point x,y." },
{ "TerrainData.GetHeights", "Get an array of heightmap samples.." },
{ "TerrainData.GetInterpolatedHeight", "Gets an interpolated height at a point x,y." },
{ "TerrainData.GetInterpolatedNormal", "Get an interpolated normal at a given location." },
{ "TerrainData.GetSteepness", "Gets the gradient of the terrain at point <x,y>." },
{ "TerrainData.GetSupportedLayers", "Returns an array of all supported detail layer indices in the area." },
{ "TerrainData.RefreshPrototypes", "Reloads all the values of the available prototypes (ie, detail mesh assets) in the TerrainData Object." },
{ "TerrainData.SetAlphamaps", "Assign all splat values in the given map area." },
{ "TerrainData.SetDetailLayer", "Sets the detail layer density map." },
{ "TerrainData.SetDetailResolution", "Set the resolution of the detail map." },
{ "TerrainData.SetHeights", "Set an array of heightmap samples." },
{ "TextAlignment", "How multiline text should be aligned." },
{ "TextAlignment.Center", "Text lines are centered." },
{ "TextAlignment.Left", "Text lines are aligned on the left side." },
{ "TextAlignment.Right", "Text lines are aligned on the right side." },
{ "TextAnchor", "Where the anchor of the text is placed." },
{ "TextAnchor.LowerCenter", "Text is anchored in lower side, centered horizontally." },
{ "TextAnchor.LowerLeft", "Text is anchored in lower left corner." },
{ "TextAnchor.LowerRight", "Text is anchored in lower right corner." },
{ "TextAnchor.MiddleCenter", "Text is centered both horizontally and vertically." },
{ "TextAnchor.MiddleLeft", "Text is anchored in left side, centered vertically." },
{ "TextAnchor.MiddleRight", "Text is anchored in right side, centered vertically." },
{ "TextAnchor.UpperCenter", "Text is anchored in upper side, centered horizontally." },
{ "TextAnchor.UpperLeft", "Text is anchored in upper left corner." },
{ "TextAnchor.UpperRight", "Text is anchored in upper right corner." },
{ "TextAreaAttribute", "Attribute to make a string be edited with a height-flexible and scrollable text area." },
{ "TextAreaAttribute-ctor", "Attribute to make a string be edited with a height-flexible and scrollable text area." },
{ "TextAreaAttribute-maxLines", "The maximum amount of lines the text area can show before it starts using a scrollbar." },
{ "TextAreaAttribute-minLines", "The minimum amount of lines the text area will use." },
{ "TextAsset", "Text file assets." },
{ "TextAsset-bytes", "The raw bytes of the text asset. (Read Only)" },
{ "TextAsset-text", "The text contents of the .txt file as a string. (Read Only)" },
{ "TextClipping", "Different methods for how the GUI system handles text being too large to fit the rectangle allocated." },
{ "TextClipping.Clip", "Text gets clipped to be inside the element." },
{ "TextClipping.Overflow", "Text flows freely outside the element." },
{ "TextGenerationSettings", "A struct that stores the settings for TextGeneration." },
{ "TextGenerator", "Class that can be used to generate text for rendering." },
{ "TextGenerator-characterCount", "The number of characters that have been generated." },
{ "TextGenerator-characters", "Array of generated characters." },
{ "TextGenerator-ctor", "Create a TextGenerator." },
{ "TextGenerator-extents", "Extends of generated text area." },
{ "TextGenerator-lineCount", "Number of text lines generated." },
{ "TextGenerator-lines", "Information about each generated text line." },
{ "TextGenerator-rectExtents", "Extents of the generated text in rect format." },
{ "TextGenerator-vertexCount", "Number of vertices generated." },
{ "TextGenerator-verts", "Array of generated vertices." },
{ "TextGenerator.GetCharacters", "Populate the given array with UICharInfo." },
{ "TextGenerator.GetLines", "Populate the given array with UILineInfo." },
{ "TextGenerator.GetVerts", "Populate the given array with UIVertex." },
{ "TextGenerator.Invalidate", "Mark the text generator as invalid. This will force a full text generation the next time Populate is called." },
{ "TextGenerator.Populate", "Will generate the vertices and other data for the given string with the given settings." },
{ "TextMesh", "A script interface for the text mesh component." },
{ "TextMesh-alignment", "How lines of text are aligned (Left, Right, Center)." },
{ "TextMesh-anchor", "Which point of the text shares the position of the Transform." },
{ "TextMesh-characterSize", "The size of each character (This scales the whole text)." },
{ "TextMesh-color", "The color used to render the text." },
{ "TextMesh-font", "The Font used." },
{ "TextMesh-fontSize", "The font size to use (for dynamic fonts)." },
{ "TextMesh-fontStyle", "The font style to use (for dynamic fonts)." },
{ "TextMesh-lineSpacing", "How much space will be in-between lines of text." },
{ "TextMesh-offsetZ", "How far should the text be offset from the transform.position.z when drawing." },
{ "TextMesh-richText", "Enable HTML-style tags for Text Formatting Markup." },
{ "TextMesh-tabSize", "How much space will be inserted for a tab '\t' character. This is a multiplum of the 'spacebar' character offset." },
{ "TextMesh-text", "The text that is displayed." },
{ "Texture", "Base class for texture handling. Contains functionality that is common to both Texture2D and RenderTexture classes." },
{ "Texture-anisoLevel", "Anisotropic filtering level of the texture." },
{ "Texture-filterMode", "Filtering mode of the texture." },
{ "Texture-height", "Height of the texture in pixels. (Read Only)" },
{ "Texture-mipMapBias", "Mip map bias of the texture." },
{ "Texture-width", "Width of the texture in pixels. (Read Only)" },
{ "Texture-wrapMode", "Wrap mode (Repeat or Clamp) of the texture." },
{ "Texture.GetNativeTextureID", "Retrieve native ('hardware') handle to a texture." },
{ "Texture.GetNativeTexturePtr", "Retrieve native ('hardware') pointer to a texture." },
{ "Texture.SetGlobalAnisotropicFilteringLimits", "Sets Anisotropic limits." },
{ "Texture2D", "Class for texture handling." },
{ "Texture2D-ctor", "Create a new empty texture." },
{ "Texture2D-format", "The format of the pixel data in the texture (Read Only)." },
{ "Texture2D-mipmapCount", "How many mipmap levels are in this texture (Read Only)." },
{ "Texture2D.Apply", "Actually apply all previous SetPixel and SetPixels changes." },
{ "Texture2D.Compress", "Compress texture into DXT format." },
{ "Texture2D.CreateExternalTexture", "Creates Unity Texture on top of already inited native texture object." },
{ "Texture2D.EncodeToJPG", "Encodes this texture into JPG format." },
{ "Texture2D.EncodeToPNG", "Encodes this texture into PNG format." },
{ "Texture2D.GetPixel", "Returns pixel color at coordinates (x, y)." },
{ "Texture2D.GetPixelBilinear", "Returns filtered pixel color at normalized coordinates (u, v)." },
{ "Texture2D.GetPixels", "Get a block of pixel colors." },
{ "Texture2D.GetPixels32", "Get a block of pixel colors in Color32 format." },
{ "Texture2D.LoadImage", "Loads an image from a byte array." },
{ "Texture2D.PackTextures", "Packs multiple Textures into a texture atlas." },
{ "Texture2D.ReadPixels", "Read screen pixels into the saved texture data." },
{ "Texture2D.Resize", "Resizes the texture." },
{ "Texture2D.SetPixel", "Sets pixel color at coordinates (x,y)." },
{ "Texture2D.SetPixels", "Set a block of pixel colors." },
{ "Texture2D.SetPixels32", "Set a block of pixel colors." },
{ "Texture2D.UpdateExternalTexture", "Updates Unity Texture to use different native texture object." },
{ "Texture3D", "Class for handling 3D Textures, Use this to create 3D texture assets." },
{ "Texture3D-ctor", "Create a new empty 3D Texture." },
{ "Texture3D-depth", "The depth of the texture." },
{ "Texture3D-format", "The format of the pixel data in the texture (Read Only)." },
{ "Texture3D.Apply", "Actually apply all previous SetPixels changes." },
{ "Texture3D.GetPixels", "This function returns an array of pixel colors representing one mip level of the 3D texture." },
{ "Texture3D.SetPixels", "This function takes a color array and changes the pixel colors of the 3D texture." },
{ "TextureCompressionQuality", "Compression Quality." },
{ "TextureCompressionQuality.Best", "Best compression." },
{ "TextureCompressionQuality.Fast", "Fast compression." },
{ "TextureCompressionQuality.Normal", "Normal compression (default)." },
{ "TextureFormat", "Format of a texture. Used when creating textures from scripts." },
{ "TextureFormat.Alpha8", "Alpha-only texture format." },
{ "TextureFormat.ARGB32", "Color with an alpha channel texture format." },
{ "TextureFormat.ARGB4444", "A 16 bits/pixel texture format. Texture stores color with an alpha channel." },
{ "TextureFormat.ASTC_RGB_10x10", "ASTC (10x10 pixel block in 128 bits) compressed RGB texture format." },
{ "TextureFormat.ASTC_RGB_12x12", "ASTC (12x12 pixel block in 128 bits) compressed RGB texture format." },
{ "TextureFormat.ASTC_RGB_4x4", "ASTC (4x4 pixel block in 128 bits) compressed RGB texture format." },
{ "TextureFormat.ASTC_RGB_5x5", "ASTC (5x5 pixel block in 128 bits) compressed RGB texture format." },
{ "TextureFormat.ASTC_RGB_6x6", "ASTC (6x6 pixel block in 128 bits) compressed RGB texture format." },
{ "TextureFormat.ASTC_RGB_8x8", "ASTC (8x8 pixel block in 128 bits) compressed RGB texture format." },
{ "TextureFormat.ASTC_RGBA_10x10", "ASTC (10x10 pixel block in 128 bits) compressed RGBA texture format." },
{ "TextureFormat.ASTC_RGBA_12x12", "ASTC (12x12 pixel block in 128 bits) compressed RGBA texture format." },
{ "TextureFormat.ASTC_RGBA_4x4", "ASTC (4x4 pixel block in 128 bits) compressed RGBA texture format." },
{ "TextureFormat.ASTC_RGBA_5x5", "ASTC (5x5 pixel block in 128 bits) compressed RGBA texture format." },
{ "TextureFormat.ASTC_RGBA_6x6", "ASTC (6x6 pixel block in 128 bits) compressed RGBA texture format." },
{ "TextureFormat.ASTC_RGBA_8x8", "ASTC (8x8 pixel block in 128 bits) compressed RGBA texture format." },
{ "TextureFormat.ATC_RGB4", "ATC (ATITC) 4 bits/pixel compressed RGB texture format." },
{ "TextureFormat.ATC_RGBA8", "ATC (ATITC) 8 bits/pixel compressed RGB texture format." },
{ "TextureFormat.ATF_RGB_DXT1", "Flash-specific RGB DXT1 compressed color texture format." },
{ "TextureFormat.ATF_RGB_JPG", "Flash-specific RGB JPG-compressed color texture format." },
{ "TextureFormat.ATF_RGBA_JPG", "Flash-specific RGBA JPG-compressed color texture format." },
{ "TextureFormat.BGRA32", "Format returned by iPhone camera." },
{ "TextureFormat.DXT1", "Compressed color texture format." },
{ "TextureFormat.DXT5", "Compressed color with alpha channel texture format." },
{ "TextureFormat.EAC_R", "ETC2 / EAC (GL ES 3.0) 4 bits/pixel compressed unsigned single-channel texture format." },
{ "TextureFormat.EAC_R_SIGNED", "ETC2 / EAC (GL ES 3.0) 4 bits/pixel compressed signed single-channel texture format." },
{ "TextureFormat.EAC_RG", "ETC2 / EAC (GL ES 3.0) 8 bits/pixel compressed unsigned dual-channel (RG) texture format." },
{ "TextureFormat.EAC_RG_SIGNED", "ETC2 / EAC (GL ES 3.0) 8 bits/pixel compressed signed dual-channel (RG) texture format." },
{ "TextureFormat.ETC2_RGB", "ETC2 (GL ES 3.0) 4 bits/pixel compressed RGB texture format." },
{ "TextureFormat.ETC2_RGBA1", "ETC2 (GL ES 3.0) 4 bits/pixel RGB+1-bit alpha texture format." },
{ "TextureFormat.ETC2_RGBA8", "ETC2 (GL ES 3.0) 8 bits/pixel compressed RGBA texture format." },
{ "TextureFormat.ETC_RGB4", "ETC (GLES2.0) 4 bits/pixel compressed RGB texture format." },
{ "TextureFormat.PVRTC_RGB2", "PowerVR (iOS) 2 bits/pixel compressed color texture format." },
{ "TextureFormat.PVRTC_RGB4", "PowerVR (iOS) 4 bits/pixel compressed color texture format." },
{ "TextureFormat.PVRTC_RGBA2", "PowerVR (iOS) 2 bits/pixel compressed with alpha channel texture format." },
{ "TextureFormat.PVRTC_RGBA4", "PowerVR (iOS) 4 bits/pixel compressed with alpha channel texture format." },
{ "TextureFormat.RGB24", "A color texture format." },
{ "TextureFormat.RGB565", "A 16 bit color texture format." },
{ "TextureImporter", "Texture importer lets you modify Texture2D import settings from editor scripts." },
{ "TextureImporter-anisoLevel", "Anisotropic filtering level of the texture." },
{ "TextureImporter-borderMipmap", "Keep texture borders the same when generating mipmaps?" },
{ "TextureImporter-compressionQuality", "Quality of Texture Compression in the range [0..100]." },
{ "TextureImporter-convertToNormalmap", "Convert heightmap to normal map?" },
{ "TextureImporter-fadeout", "Fade out mip levels to gray color?" },
{ "TextureImporter-filterMode", "Filtering mode of the texture." },
{ "TextureImporter-generateCubemap", "Cubemap generation mode." },
{ "TextureImporter-generateMipsInLinearSpace", "Should mip maps be generated with gamma correction?" },
{ "TextureImporter-grayscaleToAlpha", "Generate alpha channel from intensity?" },
{ "TextureImporter-heightmapScale", "Amount of bumpyness in the heightmap." },
{ "TextureImporter-isReadable", "Is texture data readable from scripts." },
{ "TextureImporter-lightmap", "Is this texture a lightmap?" },
{ "TextureImporter-linearTexture", "When in linear rendering should this texture be sampled with hardware gamma correction (sRGB) or without (linear)?" },
{ "TextureImporter-maxTextureSize", "Maximum texture size." },
{ "TextureImporter-mipMapBias", "Mip map bias of the texture." },
{ "TextureImporter-mipmapEnabled", "Generate mip maps for the texture?" },
{ "TextureImporter-mipmapFadeDistanceEnd", "Mip level where texture is faded out completely." },
{ "TextureImporter-mipmapFadeDistanceStart", "Mip level where texture begins to fade out." },
{ "TextureImporter-mipmapFilter", "Mipmap filtering mode." },
{ "TextureImporter-normalmap", "Is this texture a normal map?" },
{ "TextureImporter-normalmapFilter", "Normal map filtering mode." },
{ "TextureImporter-npotScale", "Scaling mode for non power of two textures." },
{ "TextureImporter-qualifiesForSpritePacking", "Returns true if this TextureImporter is setup for Sprite packing." },
{ "TextureImporter-spriteBorder", "Border sizes of the generated sprites." },
{ "TextureImporter-spriteImportMode", "Selects Single or Manual import mode for Sprite textures." },
{ "TextureImporter-spritePackingTag", "Selects the Sprite packing tag." },
{ "TextureImporter-spritePivot", "The point in the Sprite object's coordinate space where the graphic is located." },
{ "TextureImporter-spritePixelsToUnits", "Scale factor for mapping pixels in the graphic to units in world space." },
{ "TextureImporter-spritesheet", "Array representing the sections of the atlas corresponding to individual sprite graphics." },
{ "TextureImporter-textureFormat", "Format of imported texture." },
{ "TextureImporter-textureType", "Which type of texture are we dealing with here." },
{ "TextureImporter-wrapMode", "Wrap mode (Repeat or Clamp) of the texture." },
{ "TextureImporter.ClearPlatformTextureSettings", "Clear specific target platform settings." },
{ "TextureImporter.DoesSourceTextureHaveAlpha", "Does textures source image have alpha channel." },
{ "TextureImporter.DoesSourceTextureHaveColor", "Does textures source image have RGB channels." },
{ "TextureImporter.GetPlatformTextureSettings", "Get platform specific texture settings." },
{ "TextureImporter.ReadTextureImportInstructions", "Reads the active texture output instructions of this TextureImporter." },
{ "TextureImporter.ReadTextureSettings", "Read texture settings into TextureImporterSettings class." },
{ "TextureImporter.SetPlatformTextureSettings", "Set specific target platform settings." },
{ "TextureImporter.SetTextureSettings", "Set texture importers settings from TextureImporterSettings class." },
{ "TextureImporterFormat", "Imported texture format for TextureImporter." },
{ "TextureImporterFormat.Alpha8", "Alpha 8 bit texture format." },
{ "TextureImporterFormat.ARGB16", "RGBA 16 bit texture format." },
{ "TextureImporterFormat.ARGB32", "ARGB 32 bit texture format." },
{ "TextureImporterFormat.ASTC_RGB_10x10", "ASTC compressed RGB texture format, 10x10 block size." },
{ "TextureImporterFormat.ASTC_RGB_12x12", "ASTC compressed RGB texture format, 12x12 block size." },
{ "TextureImporterFormat.ASTC_RGB_4x4", "ASTC compressed RGB texture format, 4x4 block size." },
{ "TextureImporterFormat.ASTC_RGB_5x5", "ASTC compressed RGB texture format, 5x5 block size." },
{ "TextureImporterFormat.ASTC_RGB_6x6", "ASTC compressed RGB texture format, 6x6 block size." },
{ "TextureImporterFormat.ASTC_RGB_8x8", "ASTC compressed RGB texture format, 8x8 block size." },
{ "TextureImporterFormat.ASTC_RGBA_10x10", "ASTC compressed RGBA texture format, 10x10 block size." },
{ "TextureImporterFormat.ASTC_RGBA_12x12", "ASTC compressed RGBA texture format, 12x12 block size." },
{ "TextureImporterFormat.ASTC_RGBA_4x4", "ASTC compressed RGBA texture format, 4x4 block size." },
{ "TextureImporterFormat.ASTC_RGBA_5x5", "ASTC compressed RGBA texture format, 5x5 block size." },
{ "TextureImporterFormat.ASTC_RGBA_6x6", "ASTC compressed RGBA texture format, 6x6 block size." },
{ "TextureImporterFormat.ASTC_RGBA_8x8", "ASTC compressed RGBA texture format, 8x8 block size." },
{ "TextureImporterFormat.ATC_RGB4", "ATC (Android) 4 bits/pixel compressed RGB texture format." },
{ "TextureImporterFormat.ATC_RGBA8", "ATC (Android) 8 bits/pixel compressed RGBA texture format." },
{ "TextureImporterFormat.ATF_RGB_DXT1", "Flash-specific RGB DXT1 compressed color texture format." },
{ "TextureImporterFormat.ATF_RGB_JPG", "Flash-specific RGB JPG-compressed color texture format." },
{ "TextureImporterFormat.ATF_RGBA_JPG", "Flash-specific RGBA JPG-compressed color texture format." },
{ "TextureImporterFormat.Automatic16bit", "Choose a 16 bit format automatically." },
{ "TextureImporterFormat.AutomaticCompressed", "Choose a compressed format automatically." },
{ "TextureImporterFormat.AutomaticTruecolor", "Choose a Truecolor format automatically." },
{ "TextureImporterFormat.DXT1", "DXT1 compresed texture format." },
{ "TextureImporterFormat.DXT5", "DXT5 compresed texture format." },
{ "TextureImporterFormat.EAC_R", "ETC2/EAC compressed 4 bits / pixel unsigned R texture format." },
{ "TextureImporterFormat.EAC_R_SIGNED", "ETC2/EAC compressed 4 bits / pixel signed R texture format." },
{ "TextureImporterFormat.EAC_RG", "ETC2/EAC compressed 8 bits / pixel unsigned RG texture format." },
{ "TextureImporterFormat.EAC_RG_SIGNED", "ETC2/EAC compressed 4 bits / pixel signed RG texture format." },
{ "TextureImporterFormat.ETC2_RGB4", "ETC2 compressed 4 bits / pixel RGB texture format." },
{ "TextureImporterFormat.ETC2_RGB4_PUNCHTHROUGH_ALPHA", "ETC2 compressed 4 bits / pixel RGB + 1-bit alpha texture format." },
{ "TextureImporterFormat.ETC2_RGBA8", "ETC2 compressed 8 bits / pixel RGBA texture format." },
{ "TextureImporterFormat.ETC_RGB4", "ETC (GLES2.0) 4 bits/pixel compressed RGB texture format." },
{ "TextureImporterFormat.PVRTC_RGB2", "PowerVR (iPhone) 2 bits/pixel compressed color texture format." },
{ "TextureImporterFormat.PVRTC_RGB4", "PowerVR (iPhone) 4 bits/pixel compressed color texture format." },
{ "TextureImporterFormat.PVRTC_RGBA2", "PowerVR (iPhone) 2 bits/pixel compressed with alpha channel texture format." },
{ "TextureImporterFormat.PVRTC_RGBA4", "PowerVR (iPhone) 4 bits/pixel compressed with alpha channel texture format." },
{ "TextureImporterFormat.RGB16", "RGB 16 bit texture format." },
{ "TextureImporterFormat.RGB24", "RGB 24 bit texture format." },
{ "TextureImporterFormat.RGBA16", "RGBA 16 bit (4444) texture format." },
{ "TextureImporterFormat.RGBA32", "RGBA 32 bit texture format." },
{ "TextureImporterGenerateCubemap", "Cubemap generation mode for TextureImporter." },
{ "TextureImporterGenerateCubemap.Cylindrical", "Generate cubemap from cylindrical texture." },
{ "TextureImporterGenerateCubemap.FullCubemap", "Generate cubemap from vertical or horizontal cross texture." },
{ "TextureImporterGenerateCubemap.NiceSpheremap", "Generate cubemap from spheremap texture." },
{ "TextureImporterGenerateCubemap.None", "Do not generate cubemap (default)." },
{ "TextureImporterGenerateCubemap.SimpleSpheremap", "Generate cubemap from spheremap texture." },
{ "TextureImporterGenerateCubemap.Spheremap", "Generate cubemap from spheremap texture." },
{ "TextureImporterMipFilter", "Mip map filter for TextureImporter." },
{ "TextureImporterMipFilter.BoxFilter", "Box mipmap filter." },
{ "TextureImporterMipFilter.KaiserFilter", "Kaiser mipmap filter." },
{ "TextureImporterNormalFilter", "Normal map filtering mode for TextureImporter." },
{ "TextureImporterNormalFilter.Sobel", "Sobel normal map filter." },
{ "TextureImporterNormalFilter.Standard", "Standard normal map filter." },
{ "TextureImporterNPOTScale", "Scaling mode for non power of two textures in TextureImporter." },
{ "TextureImporterNPOTScale.None", "Keep non power of two textures as is." },
{ "TextureImporterNPOTScale.ToLarger", "Scale to larger power of two." },
{ "TextureImporterNPOTScale.ToNearest", "Scale to nearest power of two." },
{ "TextureImporterNPOTScale.ToSmaller", "Scale to smaller power of two." },
{ "TextureImporterSettings", "Stores settings of a TextureImporter." },
{ "TextureImporterSettings-spriteAlignment", "Edge-relative alignment of the sprite graphic." },
{ "TextureImporterSettings-spriteBorder", "Border sizes of the generated sprites." },
{ "TextureImporterSettings-spriteExtrude", "The number of blank pixels to leave between the edge of the graphic and the mesh." },
{ "TextureImporterSettings-spriteMode", "Sprite texture import mode." },
{ "TextureImporterSettings-spritePivot", "Pivot point of the Sprite relative to its graphic's rectangle." },
{ "TextureImporterSettings-spritePixelsToUnits", "Scale factor between pixels in the sprite graphic and world space units." },
{ "TextureImporterSettings.ApplyTextureType", "Configure parameters to import a texture for a purpose of type, as described here." },
{ "TextureImporterSettings.CopyTo", "Copy parameters into another TextureImporterSettings object." },
{ "TextureImporterSettings.Equal", "Test texture importer settings for equality." },
{ "TextureImporterType", "Select this to set basic parameters depending on the purpose of your texture." },
{ "TextureImporterType.Advanced", "Select this when you want to have specific parameters on your texture and you want to have total control over your texture." },
{ "TextureImporterType.Bump", "Select this to turn the color channels into a format suitable for real-time normal mapping." },
{ "TextureImporterType.Cookie", "This sets up your texture with the basic parameters used for the Cookies of your lights." },
{ "TextureImporterType.Cursor", "Use this if your texture is going to be used as a cursor." },
{ "TextureImporterType.GUI", "Use this if your texture is going to be used on any HUD/GUI Controls." },
{ "TextureImporterType.Image", "This is the most common setting used for all the textures in general." },
{ "TextureImporterType.Lightmap", "This sets up your texture with the parameters used by the lightmap." },
{ "TextureImporterType.Reflection", "Also known as Cube Maps, used to create reflections on textures." },
{ "TextureImporterType.Sprite", "Select this if you will be using your texture for Sprite graphics." },
{ "TextureWrapMode", "Wrap mode for textures." },
{ "TextureWrapMode.Clamp", "Clamps the texture to the last pixel at the border." },
{ "TextureWrapMode.Repeat", "Tiles the texture, creating a repeating pattern." },
{ "TextWrapMode", "Text wrap mode for GUI Rendering." },
{ "TextWrapMode.BestFit", "Shrink or Grow the text so that it fits the given area as best it can." },
{ "TextWrapMode.GrowText", "Grow the text so that it fills the given bounds." },
{ "TextWrapMode.ResizeBounds", "Text rendering ignores bounds." },
{ "TextWrapMode.ShrinkText", "If the text does not fit in the given bounds it will be resized until it fits in the bounds." },
{ "TextWrapMode.Wrap", "Text will wrap within the given bounds. Text that does not fit (y axis) will be clipped." },
{ "ThreadPriority", "Priority of a thread." },
{ "ThreadPriority.BelowNormal", "Below normal thread priority." },
{ "ThreadPriority.High", "Highest thread priority." },
{ "ThreadPriority.Low", "Lowest thread priority." },
{ "ThreadPriority.Normal", "Normal thread priority." },
{ "Time", "The interface to get time information from Unity." },
{ "Time-captureFramerate", "Slows game playback time to allow screenshots to be saved between frames." },
{ "Time-deltaTime", "The time in seconds it took to complete the last frame (Read Only)." },
{ "Time-fixedDeltaTime", "The interval in seconds at which physics and other fixed frame rate updates (like MonoBehaviour's FixedUpdate) are performed." },
{ "Time-fixedTime", "The time the latest FixedUpdate has started (Read Only). This is the time in seconds since the start of the game." },
{ "Time-frameCount", "The total number of frames that have passed (Read Only)." },
{ "Time-maximumDeltaTime", "The maximum time a frame can take. Physics and other fixed frame rate updates (like MonoBehaviour's FixedUpdate)." },
{ "Time-realtimeSinceStartup", "The real time in seconds since the game started (Read Only)." },
{ "Time-smoothDeltaTime", "A smoothed out Time.deltaTime (Read Only)." },
{ "Time-time", "The time at the beginning of this frame (Read Only). This is the time in seconds since the start of the game." },
{ "Time-timeScale", "The scale at which the time is passing. This can be used for slow motion effects." },
{ "Time-timeSinceLevelLoad", "The time this frame has started (Read Only). This is the time in seconds since the last level has been loaded." },
{ "Time-unscaledDeltaTime", "The timeScale-independent time in seconds it took to complete the last frame (Read Only)." },
{ "Time-unscaledTime", "The timeScale-independant time at the beginning of this frame (Read Only). This is the time in seconds since the start of the game." },
{ "TizenBuildSubtarget", "Texture Compression Types." },
{ "TizenBuildSubtarget.ATC", "ATI texture compression. Available on Tizen devices running Adreno GPU." },
{ "TizenBuildSubtarget.ETC", "ETC1 texture compression (or RGBA16 for textures with alpha), supported by all devices." },
{ "TizenBuildSubtarget.Generic", "Don't override texture compression." },
{ "Tool", "Which tool is active in the editor." },
{ "Tool.Move", "The move tool is active." },
{ "Tool.None", "No tool is active. Set this to implement your own in-inspector toolbar (like the terrain editor does)." },
{ "Tool.Rotate", "The rotate tool is active." },
{ "Tool.Scale", "The scale tool is active." },
{ "Tool.View", "The view tool is active - Use Tools.viewTool to find out which view tool we're talking about." },
{ "Tools", "Class used to manipulate the tools used in Unity's Scene View." },
{ "Tools-current", "The tool that is currently selected for the Scene View." },
{ "Tools-handlePosition", "The position of the tool handle in world space." },
{ "Tools-handleRotation", "The rotation of the tool handle in world space." },
{ "Tools-hidden", "Hides the Tools(Move, Rotate, Resize) on the Scene view." },
{ "Tools-pivotMode", "Are we in Center or Pivot mode." },
{ "Tools-pivotRotation", "What's the rotation of the tool handle." },
{ "Tools-viewTool", "The option that is currently active for the View tool in the Scene view." },
{ "Tools-visibleLayers", "Which layers are visible in the scene view." },
{ "TooltipAttribute", "Specify a tooltip for a field." },
{ "TooltipAttribute-ctor", "Specify a tooltip for a field." },
{ "TooltipAttribute-tooltip", "The tooltip text." },
{ "Touch", "Structure describing the status of a finger touching the screen." },
{ "Touch-deltaPosition", "The position delta since last change." },
{ "Touch-deltaTime", "Amount of time that has passed since the last recorded change in Touch values." },
{ "Touch-fingerId", "The unique index for the touch." },
{ "Touch-phase", "Describes the phase of the touch." },
{ "Touch-position", "The position of the touch in pixel coordinates." },
{ "Touch-tapCount", "Number of taps." },
{ "TouchPhase", "Describes phase of a finger touch." },
{ "TouchPhase.Began", "A finger touched the screen." },
{ "TouchPhase.Canceled", "The system cancelled tracking for the touch." },
{ "TouchPhase.Ended", "A finger was lifted from the screen. This is the final phase of a touch." },
{ "TouchPhase.Moved", "A finger moved on the screen." },
{ "TouchPhase.Stationary", "A finger is touching the screen but hasn't moved." },
{ "TouchScreenKeyboard", "Interface into the native iPhone and Android on-screen keyboards - it is not available on other platforms." },
{ "TouchScreenKeyboard-active", "Is the keyboard visible or sliding into the position on the screen?" },
{ "TouchScreenKeyboard-area", "Returns portion of the screen which is covered by the keyboard." },
{ "TouchScreenKeyboard-done", "Specifies if input process was finished. (Read Only)" },
{ "TouchScreenKeyboard-hideInput", "Will text input field above the keyboard be hidden when the keyboard is on screen?" },
{ "TouchScreenKeyboard-text", "Returns the text displayed by the input field of the keyboard." },
{ "TouchScreenKeyboard-visible", "Returns true whenever any keyboard is completely visible on the screen." },
{ "TouchScreenKeyboard-wasCanceled", "Specifies if input process was canceled. (Read Only)" },
{ "TouchScreenKeyboard.Open", "Opens the native keyboard provided by OS on the screen." },
{ "TouchScreenKeyboardType", "Describes the type of keyboard." },
{ "TouchScreenKeyboardType.ASCIICapable", "Keyboard displays standard ASCII characters." },
{ "TouchScreenKeyboardType.Default", "Default keyboard for the current input method." },
{ "TouchScreenKeyboardType.EmailAddress", "Keyboard optimized for specifying email addresses." },
{ "TouchScreenKeyboardType.NamePhonePad", "Keypad designed for entering a person's name or phone number." },
{ "TouchScreenKeyboardType.NumberPad", "Numeric keypad designed for PIN entry." },
{ "TouchScreenKeyboardType.NumbersAndPunctuation", "Keyboard with numbers and punctuation." },
{ "TouchScreenKeyboardType.PhonePad", "Keypad designed for entering telephone numbers." },
{ "TouchScreenKeyboardType.URL", "Keyboard optimized for URL entry." },
{ "TrailRenderer", "The trail renderer is used to make trails behind objects in the scene as they move about." },
{ "TrailRenderer-autodestruct", "Does the GameObject of this trail renderer auto destructs?" },
{ "TrailRenderer-endWidth", "The width of the trail at the end of the trail." },
{ "TrailRenderer-startWidth", "The width of the trail at the spawning point." },
{ "TrailRenderer-time", "How long does the trail take to fade out." },
{ "Transform", "Position, rotation and scale of an object." },
{ "Transform-childCount", "The number of children the Transform has." },
{ "Transform-eulerAngles", "The rotation as Euler angles in degrees." },
{ "Transform-forward", "The blue axis of the transform in world space." },
{ "Transform-hasChanged", "Has the transform changed since the last time the flag was set to 'false'?" },
{ "Transform-localEulerAngles", "The rotation as Euler angles in degrees relative to the parent transform's rotation." },
{ "Transform-localPosition", "Position of the transform relative to the parent transform." },
{ "Transform-localRotation", "The rotation of the transform relative to the parent transform's rotation." },
{ "Transform-localScale", "The scale of the transform relative to the parent." },
{ "Transform-localToWorldMatrix", "Matrix that transforms a point from local space into world space (Read Only)." },
{ "Transform-lossyScale", "The global scale of the object (Read Only)." },
{ "Transform-parent", "The parent of the transform." },
{ "Transform-position", "The position of the transform in world space." },
{ "Transform-right", "The red axis of the transform in world space." },
{ "Transform-root", "Returns the topmost transform in the hierarchy." },
{ "Transform-rotation", "The rotation of the transform in world space stored as a Quaternion." },
{ "Transform-up", "The green axis of the transform in world space." },
{ "Transform-worldToLocalMatrix", "Matrix that transforms a point from world space into local space (Read Only)." },
{ "Transform.DetachChildren", "Unparents all children." },
{ "Transform.Find", "Finds a child by name and returns it." },
{ "Transform.GetChild", "Returns a transform child by index." },
{ "Transform.GetSiblingIndex", "Gets the sibling index." },
{ "Transform.InverseTransformDirection", "Transforms a direction from world space to local space. The opposite of Transform.TransformDirection." },
{ "Transform.InverseTransformPoint", "Transforms position from world space to local space. The opposite of Transform.TransformPoint." },
{ "Transform.IsChildOf", "Is this transform a child of /parent/?" },
{ "Transform.LookAt", "Rotates the transform so the forward vector points at /target/'s current position." },
{ "Transform.Rotate", "Applies a rotation of /eulerAngles.z/ degrees around the z axis, /eulerAngles.x/ degrees around the x axis, and /eulerAngles.y/ degrees around the y axis (in that order)." },
{ "Transform.RotateAround", "Rotates the transform about axis passing through point in world coordinates by angle degrees." },
{ "Transform.SetAsFirstSibling", "Move the transform to the start of the local transfrom list." },
{ "Transform.SetAsLastSibling", "Move the transform to the end of the local transfrom list." },
{ "Transform.SetSiblingIndex", "Sets the sibling index." },
{ "Transform.TransformDirection", "Transforms direction from local space to world space." },
{ "Transform.TransformPoint", "Transforms position from local space to world space." },
{ "Transform.Translate", "Moves the transform in the direction and distance of translation." },
{ "TransformSort", "Is the default sorting method used by the hierarchy." },
{ "TransformSort-content", "Content to visualize the transform sorting method." },
{ "TransparencySortMode", "Transparent object sorting mode of a Camera." },
{ "TransparencySortMode.Default", "Default sorting mode." },
{ "TransparencySortMode.Orthographic", "Orthographic sorting mode." },
{ "TransparencySortMode.Perspective", "Perspective sorting mode." },
{ "Tree", "Tree Component for the tree creator." },
{ "Tree-data", "Data asociated to the Tree." },
{ "TreeInstance", "Contains information about a tree placed in the Terrain game object." },
{ "TreeInstance-color", "Color of this instance." },
{ "TreeInstance-heightScale", "Height scale of this instance (compared to the prototype's size)." },
{ "TreeInstance-lightmapColor", "Lightmap color calculated for this instance." },
{ "TreeInstance-position", "Position of the tree." },
{ "TreeInstance-prototypeIndex", "Index of this instance in the TerrainData.treePrototypes array." },
{ "TreeInstance-widthScale", "Width scale of this instance (compared to the prototype's size)." },
{ "TreePrototype", "Simple class that contains a pointer to a tree prototype." },
{ "TreePrototype-bendFactor", "Bend factor of the tree prototype." },
{ "TreePrototype-prefab", "Retrieves the actual GameObect used by the tree." },
{ "TrueTypeFontImporter", "AssetImporter for importing Fonts." },
{ "TrueTypeFontImporter-characterPadding", "Border pixels added to character images for padding. This is useful if you want to render text using a shader which needs to render outside of the character area (like an outline shader)." },
{ "TrueTypeFontImporter-characterSpacing", "Spacing between character images in the generated texture in pixels. This is useful if you want to render text using a shader which samples pixels outside of the character area (like an outline shader)." },
{ "TrueTypeFontImporter-customCharacters", "A custom set of characters to be included in the Font Texture." },
{ "TrueTypeFontImporter-fontNames", "An array of font names, to be used when includeFontData is set to false." },
{ "TrueTypeFontImporter-fontRenderingMode", "Font rendering mode to use for this font." },
{ "TrueTypeFontImporter-fontSize", "Font size to use for importing the characters." },
{ "TrueTypeFontImporter-fontTextureCase", "Use this to adjust which characters should be imported." },
{ "TrueTypeFontImporter-fontTTFName", "The internal font name of the TTF file." },
{ "TrueTypeFontImporter-includeFontData", "If this is enabled, the actual font will be embedded into the asset for Dynamic fonts." },
{ "TrueTypeFontImporter.GenerateEditableFont", "Create an editable copy of the font asset at path." },
{ "UICharInfo", "Class that specifes some information about a renderable character." },
{ "UICharInfo-charWidth", "Character width." },
{ "UICharInfo-cursorPos", "Position of the character cursor in local (text generated) space." },
{ "UILineInfo", "Information about a generated line of text." },
{ "UILineInfo-height", "Height of the line." },
{ "UILineInfo-startCharIdx", "Index of the first character in the line." },
{ "UIOrientation", "Default mobile device orientation." },
{ "UIOrientation.AutoRotation", "Auto Rotation Enabled." },
{ "UIOrientation.LandscapeLeft", "Landscape : counter-clockwise from Portrait." },
{ "UIOrientation.LandscapeRight", "Landscape: clockwise from Portrait." },
{ "UIOrientation.Portrait", "Portrait." },
{ "UIOrientation.PortraitUpsideDown", "Portrait upside down." },
{ "UIVertex", "Vertex class used by a Canvas for managing vertices." },
{ "UIVertex-color", "Vertex color." },
{ "UIVertex-position", "Vertex position." },
{ "UIVertex-uv", "Vertex UV." },
{ "Undo", "Lets you register undo operations on specific objects you are about to perform changes on." },
{ "Undo.ClearUndo", "Removes aall Undo operation for the identifier object registered using Undo.RegisterCompleteObjectUndo from the undo stack." },
{ "Undo.CollapseUndoOperations", "Collapses all undo operation up to group index together into one step." },
{ "Undo.DestroyObjectImmediate", "Destroys the object and records an undo operation so that it can be recreated." },
{ "Undo.GetCurrentGroup", "Unity automatically groups undo operations by the current group index." },
{ "Undo.IncrementCurrentGroup", "Unity automatically groups undo operations by the current group index." },
{ "Undo.PerformRedo", "Perform an Redo operation." },
{ "Undo.PerformUndo", "Perform an Redo operation." },
{ "Undo.RecordObject", "Records any changes done on the object after the RecordObject function." },
{ "Undo.RecordObjects", "Records multiple undoable objects in a single call. This is the same as calling Undo.RecordObject multiple times." },
{ "Undo.RegisterCreatedObjectUndo", "Register an undo operations for a newly created object." },
{ "Undo.RevertAllDownToGroup", "Performs all undo operations up to the group index without storing a redo operation in the process." },
{ "Undo.RevertAllInCurrentGroup", "Performs the last undo operation but does not record a redo operation." },
{ "Undo.SetTransformParent", "Sets the parent of transform to the new parent and records an undo operation." },
{ "UndoPropertyModification", "See Also: Undo.postprocessModifications." },
{ "UnwrapParam", "Unwrapping settings." },
{ "UnwrapParam-angleError", "Maximum allowed angle distortion (0..1)." },
{ "UnwrapParam-areaError", "Maximum allowed area distortion (0..1)." },
{ "UnwrapParam-hardAngle", "This angle (or greater) between triangles will cause seam to be created." },
{ "UnwrapParam-packMargin", "How much uv-islands will be padded." },
{ "UnwrapParam.SetDefaults", "Will set default values for params." },
{ "Unwrapping", "This class holds everything you may need in regard to uv-unwrapping." },
{ "Unwrapping.GeneratePerTriangleUV", "Will generate per-triangle uv (3 uv pairs for each triangle) with default settings." },
{ "Unwrapping.GenerateSecondaryUVSet", "Will auto generate uv2 with default settings for provided mesh, and fill them in." },
{ "UserAuthorization", "Constants to pass to Application.RequestUserAuthorization." },
{ "UserAuthorization.Microphone", "Request permission to use any audio input sources attached to the computer." },
{ "UserAuthorization.WebCam", "Request permission to use any video input sources attached to the computer." },
{ "Vector2", "Representation of 2D vectors and points." },
{ "Vector2-ctor", "Constructs a new vector with given x, y components." },
{ "Vector2-magnitude", "Returns the length of this vector (Read Only)." },
{ "Vector2-normalized", "Returns this vector with a magnitude of 1 (Read Only)." },
{ "Vector2-one", "Shorthand for writing Vector2(1, 1)." },
{ "Vector2-operator_add", "Adds two vectors." },
{ "Vector2-operator_divide", "Divides a vector by a number." },
{ "Vector2-operator_eq", "Returns true if the vectors are equal." },
{ "Vector2-operator_multiply", "Multiplies a vector by a number." },
{ "Vector2-operator_ne", "Returns true if vectors different." },
{ "Vector2-operator_subtract", "Subtracts one vector from another." },
{ "Vector2-operator_Vector2", "Converts a Vector2 to a Vector3." },
{ "Vector2-operator_Vector3", "Converts a Vector3 to a Vector2." },
{ "Vector2-right", "Shorthand for writing Vector2(1, 0)." },
{ "Vector2-sqrMagnitude", "Returns the squared length of this vector (Read Only)." },
{ "Vector2-up", "Shorthand for writing Vector2(0, 1)." },
{ "Vector2-x", "X component of the vector." },
{ "Vector2-y", "Y component of the vector." },
{ "Vector2-zero", "Shorthand for writing Vector2(0, 0)." },
{ "Vector2.Angle", "Returns the angle in degrees between from and to." },
{ "Vector2.ClampMagnitude", "Returns a copy of vector with its magnitude clamped to maxLength." },
{ "Vector2.Distance", "Returns the distance between a and b." },
{ "Vector2.Dot", "Dot Product of two vectors." },
{ "Vector2.Index_operator", "Access the x or y component using [0] or [1] respectively." },
{ "Vector2.Lerp", "Linearly interpolates between two vectors." },
{ "Vector2.Max", "Returns a vector that is made from the largest components of two vectors." },
{ "Vector2.Min", "Returns a vector that is made from the smallest components of two vectors." },
{ "Vector2.MoveTowards", "Moves a point current towards target." },
{ "Vector2.Normalize", "Makes this vector have a 'magnitude of 1." },
{ "Vector2.Scale", "Multiplies two vectors component-wise." },
{ "Vector2.Set", "Set x and y components of an existing Vector2." },
{ "Vector2.ToString", "Returns a nicely formatted string for this vector." },
{ "Vector3", "Representation of 3D vectors and points." },
{ "Vector3-back", "Shorthand for writing Vector3(0, 0, -1)." },
{ "Vector3-ctor", "Creates a new vector with given x, y, z components." },
{ "Vector3-down", "Shorthand for writing Vector3(0, -1, 0)." },
{ "Vector3-forward", "Shorthand for writing Vector3(0, 0, 1)." },
{ "Vector3-left", "Shorthand for writing Vector3(-1, 0, 0)." },
{ "Vector3-magnitude", "Returns the length of this vector (Read Only)." },
{ "Vector3-normalized", "Returns this vector with a 'magnitude of 1 (Read Only)." },
{ "Vector3-one", "Shorthand for writing Vector3(1, 1, 1)." },
{ "Vector3-operator_add", "Adds two vectors." },
{ "Vector3-operator_divide", "Divides a vector by a number." },
{ "Vector3-operator_eq", "Returns true if the vectors are equal." },
{ "Vector3-operator_multiply", "Multiplies a vector by a number." },
{ "Vector3-operator_ne", "Returns true if vectors different." },
{ "Vector3-operator_subtract", "Subtracts one vector from another." },
{ "Vector3-right", "Shorthand for writing Vector3(1, 0, 0)." },
{ "Vector3-sqrMagnitude", "Returns the squared length of this vector (Read Only)." },
{ "Vector3-up", "Shorthand for writing Vector3(0, 1, 0)." },
{ "Vector3-x", "X component of the vector." },
{ "Vector3-y", "Y component of the vector." },
{ "Vector3-z", "Z component of the vector." },
{ "Vector3-zero", "Shorthand for writing Vector3(0, 0, 0)." },
{ "Vector3.Angle", "Returns the angle in degrees between from and to." },
{ "Vector3.ClampMagnitude", "Returns a copy of vector with its magnitude clamped to maxLength." },
{ "Vector3.Cross", "Cross Product of two vectors." },
{ "Vector3.Distance", "Returns the distance between a and b." },
{ "Vector3.Dot", "Dot Product of two vectors." },
{ "Vector3.Index_operator", "Access the x, y, z components using [0], [1], [2] respectively." },
{ "Vector3.Lerp", "Linearly interpolates between two vectors." },
{ "Vector3.Max", "Returns a vector that is made from the largest components of two vectors." },
{ "Vector3.Min", "Returns a vector that is made from the smallest components of two vectors." },
{ "Vector3.MoveTowards", "Moves a point current in a straight line towards a target point." },
{ "Vector3.Normalize", "" },
{ "Vector3.OrthoNormalize", "Makes vectors normalized and orthogonal to each other." },
{ "Vector3.Project", "Projects a vector onto another vector." },
{ "Vector3.Reflect", "Reflects a vector off the plane defined by a normal." },
{ "Vector3.RotateTowards", "Rotates a vector current towards target." },
{ "Vector3.Scale", "Multiplies two vectors component-wise." },
{ "Vector3.Set", "Set x, y and z components of an existing Vector3." },
{ "Vector3.Slerp", "Spherically interpolates between two vectors." },
{ "Vector3.SmoothDamp", "Gradually changes a vector towards a desired goal over time." },
{ "Vector3.ToString", "Returns a nicely formatted string for this vector." },
{ "Vector4", "Representation of four-dimensional vectors." },
{ "Vector4-ctor", "Creates a new vector with given x, y, z, w components." },
{ "Vector4-magnitude", "Returns the length of this vector (Read Only)." },
{ "Vector4-normalized", "Returns this vector with a magnitude of 1 (Read Only)." },
{ "Vector4-one", "Shorthand for writing Vector4(1,1,1,1)." },
{ "Vector4-operator_add", "Adds two vectors." },
{ "Vector4-operator_divide", "Divides a vector by a number." },
{ "Vector4-operator_eq", "Returns true if the vectors are equal." },
{ "Vector4-operator_multiply", "Multiplies a vector by a number." },
{ "Vector4-operator_ne", "Returns true if vectors different." },
{ "Vector4-operator_subtract", "Subtracts one vector from another." },
{ "Vector4-operator_Vector2", "Converts a Vector2 to a Vector4." },
{ "Vector4-operator_Vector3", "Converts a Vector3 to a Vector4." },
{ "Vector4-sqrMagnitude", "Returns the squared length of this vector (Read Only)." },
{ "Vector4-w", "W component of the vector." },
{ "Vector4-x", "X component of the vector." },
{ "Vector4-y", "Y component of the vector." },
{ "Vector4-z", "Z component of the vector." },
{ "Vector4-zero", "Shorthand for writing Vector4(0,0,0,0)." },
{ "Vector4.Distance", "Returns the distance between a and b." },
{ "Vector4.Dot", "Dot Product of two vectors." },
{ "Vector4.Index_operator", "Access the x, y, z, w components using [0], [1], [2], [3] respectively." },
{ "Vector4.Lerp", "Linearly interpolates between two vectors." },
{ "Vector4.Max", "Returns a vector that is made from the largest components of two vectors." },
{ "Vector4.Min", "Returns a vector that is made from the smallest components of two vectors." },
{ "Vector4.MoveTowards", "Moves a point current towards target." },
{ "Vector4.Normalize", "" },
{ "Vector4.Project", "Projects a vector onto another vector." },
{ "Vector4.Scale", "Multiplies two vectors component-wise." },
{ "Vector4.Set", "Set x, y, z and w components of an existing Vector4." },
{ "Vector4.ToString", "Returns a nicely formatted string for this vector." },
{ "VersionControl.Asset", "This class containes information about the version control state of an asset." },
{ "VersionControl.Asset-fullName", "Gets the full name of the asset including extension." },
{ "VersionControl.Asset-isFolder", "Returns true if the asset is a folder." },
{ "VersionControl.Asset-isInCurrentProject", "Returns true if the assets is in the current project." },
{ "VersionControl.Asset-isMeta", "Returns true if the instance of the Asset class actually refers to a .meta file." },
{ "VersionControl.Asset-locked", "Returns true if the asset is locked by the version control system." },
{ "VersionControl.Asset-name", "Get the name of the asset." },
{ "VersionControl.Asset-path", "Gets the path of the asset." },
{ "VersionControl.Asset-readOnly", "Returns true is the asset is read only." },
{ "VersionControl.Asset-state", "Gets the version control state of the asset." },
{ "VersionControl.Asset.Edit", "Opens the assets in an associated editor." },
{ "VersionControl.Asset.IsOneOfStates", "Returns true if the version control state of the assets is one of the input states." },
{ "VersionControl.Asset.IsState", "Returns true if the version control state of the asset exactly matches the input state." },
{ "VersionControl.Asset.Load", "Loads the asset to memory." },
{ "VersionControl.Asset.States", "Describes the various version control states an asset can have." },
{ "VersionControl.Asset.States.AddedLocal", "The was locally added to version control." },
{ "VersionControl.Asset.States.AddedRemote", "Remotely this asset was added to version control." },
{ "VersionControl.Asset.States.CheckedOutLocal", "The asset has been checked out on the local machine." },
{ "VersionControl.Asset.States.CheckedOutRemote", "The asset has been checked out on a remote machine." },
{ "VersionControl.Asset.States.Conflicted", "There is a conflict with the asset that needs to be resolved." },
{ "VersionControl.Asset.States.DeletedLocal", "The asset has been deleted locally." },
{ "VersionControl.Asset.States.DeletedRemote", "The asset has been deleted on a remote machine." },
{ "VersionControl.Asset.States.Local", "The asset is not under version control." },
{ "VersionControl.Asset.States.LockedLocal", "The asset is locked by the local machine." },
{ "VersionControl.Asset.States.LockedRemote", "The asset is locked by a remote machine." },
{ "VersionControl.Asset.States.MetaFile", "This instance of the class actaully refers to a .meta file." },
{ "VersionControl.Asset.States.Missing", "The asset exists in version control but is missing on the local machine." },
{ "VersionControl.Asset.States.None", "The version control state is unknown." },
{ "VersionControl.Asset.States.OutOfSync", "A newer version of the asset is available on the version control server." },
{ "VersionControl.Asset.States.ReadOnly", "The asset is read only." },
{ "VersionControl.Asset.States.Synced", "The asset is up to date." },
{ "VersionControl.Asset.States.Updating", "The state of the asset is currently being queried from the version control server." },
{ "VersionControl.AssetList", "A list of version control information about assets." },
{ "VersionControl.AssetList.Filter", "Based on the current list and the states a new list is returned which only contains the assets with the requested states." },
{ "VersionControl.AssetList.FilterChildren", "Create an optimised list of assets by removing children of folders in the same list." },
{ "VersionControl.AssetList.FilterCount", "Count the list of assets by given a set of states." },
{ "VersionControl.ChangeSet", "Wrapper around a changeset description and ID." },
{ "VersionControl.ChangeSet-description", "Description of a changeset." },
{ "VersionControl.ChangeSet-id", "Version control specific ID of a changeset." },
{ "VersionControl.ChangeSets", "Simply a list of changetsets." },
{ "VersionControl.CheckoutMode", "What to checkout when starting the Checkout task through the version control Provider." },
{ "VersionControl.CheckoutMode.Asset", "Checkout the asset only." },
{ "VersionControl.CheckoutMode.Both", "Checkout both asset and .meta file." },
{ "VersionControl.CheckoutMode.Meta", "Checkout .meta file only." },
{ "VersionControl.CompletionAction", "Different actions a version control task can do upon completion." },
{ "VersionControl.CompletionAction.OnAddedChangeWindow", "Refresh windows upon task completion." },
{ "VersionControl.CompletionAction.OnChangeContentsPendingWindow", "Update the content of a pending changeset with the result of the task upon completion." },
{ "VersionControl.CompletionAction.OnChangeSetsPendingWindow", "Update the pending changesets with the result of the task upon completion." },
{ "VersionControl.CompletionAction.OnGotLatestPendingWindow", "Refreshes the incoming and pensing changes window upon task completion." },
{ "VersionControl.CompletionAction.OnIncomingPendingWindow", "Update incoming changes window with the result of the task upon completion." },
{ "VersionControl.CompletionAction.OnSubmittedChangeWindow", "Refresh the submit window with the result of the task upon completion." },
{ "VersionControl.CompletionAction.UpdatePendingWindow", "Update the list of pending changes when a task completes." },
{ "VersionControl.ConfigField", "This class describes the." },
{ "VersionControl.ConfigField-description", "Descrition of the configuration field." },
{ "VersionControl.ConfigField-isPassword", "This is true if the configuration field is a password field." },
{ "VersionControl.ConfigField-isRequired", "This is true if the configuration field is required for the version control plugin to function correctly." },
{ "VersionControl.ConfigField-label", "Label that is displayed next to the configuration field in the editor." },
{ "VersionControl.ConfigField-name", "Name of the configuration field." },
{ "VersionControl.Message.Severity", "Severity of a version control message." },
{ "VersionControl.Message.Severity.Error", "Error message." },
{ "VersionControl.Message.Severity.Info", "Informational message." },
{ "VersionControl.Message.Severity.Verbose", "Verbose message." },
{ "VersionControl.Message.Severity.Warning", "Warning message." },
{ "VersionControl.OnlineState", "Represent the connection state of the version control provider." },
{ "VersionControl.Plugin", "The plugin class describes a version control plugin and which configuratin options it has." },
{ "VersionControl.Plugin-configFields", "Configuration fields of the plugin." },
{ "VersionControl.Provider", "This class provides acces to the version control API." },
{ "VersionControl.Provider-activeTask", "Gets the currently executing task." },
{ "VersionControl.Provider-enabled", "Returns true if the version control provider is enabled and a valid Team License was found." },
{ "VersionControl.Provider-isActive", "Returns true if a version control plugin has been selected and configured correctly." },
{ "VersionControl.Provider-offlineReason", "Returns the reason for the version control provider being offline (if it is offline)." },
{ "VersionControl.Provider-onlineState", "Returns the OnlineState of the version control provider." },
{ "VersionControl.Provider-requiresNetwork", "This is true if a network connection is required by the currently selected version control plugin to perform any action." },
{ "VersionControl.Provider.Add", "Adds an assets or list of assets to version control." },
{ "VersionControl.Provider.AddIsValid", "Given a list of assets this function returns true if Add is a valid task to perform." },
{ "VersionControl.Provider.ChangeSetDescription", "Given a changeset only containing the changeset ID, this will start a task for quering the description of the changeset." },
{ "VersionControl.Provider.ChangeSetMove", "Move an asset or list of assets from their current changeset to a new changeset." },
{ "VersionControl.Provider.ChangeSets", "Get a list of pending changesets owned by the current user." },
{ "VersionControl.Provider.ChangeSetStatus", "Retrieves the list of assets belonging to a changeset." },
{ "VersionControl.Provider.Checkout", "Checkout an asset or list of asset from the version control system." },
{ "VersionControl.Provider.CheckoutIsValid", "Given an asset or a list of assets this function returns true if Checkout is a valid task to perform." },
{ "VersionControl.Provider.ClearCache", "This will invalidate the cached state information for all assets." },
{ "VersionControl.Provider.Delete", "This will statt a task for deleting an asset or assets both from disk and from version control system." },
{ "VersionControl.Provider.DeleteChangeSets", "Starts a task that will attempt to delete the given changeset." },
{ "VersionControl.Provider.DeleteChangeSetsIsValid", "Test if deleting a changeset is a valid task to perform." },
{ "VersionControl.Provider.DiffHead", "Starts a task for showing a diff of the given assest versus their head revision." },
{ "VersionControl.Provider.DiffIsValid", "Return true is starting a Diff task is a valid operation." },
{ "VersionControl.Provider.GetActiveConfigFields", "Returns the configuration fields for the currently active version control plugin." },
{ "VersionControl.Provider.GetActivePlugin", "Gets the currently user selected verson control plugin." },
{ "VersionControl.Provider.GetAssetByGUID", "Returns version control information about an asset." },
{ "VersionControl.Provider.GetAssetByPath", "Returns version control information about an asset." },
{ "VersionControl.Provider.GetAssetListFromSelection", "Return version control information about the currently selected assets." },
{ "VersionControl.Provider.GetLatest", "Start a task for getting the latest version of an asset from the version control server." },
{ "VersionControl.Provider.GetLatestIsValid", "Returns true if getting the latest version of an asset is a valid operation." },
{ "VersionControl.Provider.Incoming", "Start a task for quering the version control server for incoming changes." },
{ "VersionControl.Provider.IncomingChangeSetAssets", "Given an incoming changeset this will start a task to query the version control server for which assets are part of the changeset." },
{ "VersionControl.Provider.IsOpenForEdit", "Returns true if an asset can be edited." },
{ "VersionControl.Provider.Lock", "Attempt to lock an asset for exclusive editing." },
{ "VersionControl.Provider.LockIsValid", "Return true if the task can be executed." },
{ "VersionControl.Provider.Merge", "This method will initiate a merge task handle merging of the conflicting assets." },
{ "VersionControl.Provider.Move", "Uses the version control plugin to move an asset from one path to another." },
{ "VersionControl.Provider.Resolve", "Start a task that will resolve conflicting assets in version control." },
{ "VersionControl.Provider.ResolveIsValid", "Tests if any of the assets in the list is resolvable." },
{ "VersionControl.Provider.Revert", "Reverts the specified assets by undoing any changes done since last time you synced." },
{ "VersionControl.Provider.RevertIsValid", "Return true if Revert is a valid task to perform." },
{ "VersionControl.Provider.Status", "Start a task that will fetch the most recent status from revision control system." },
{ "VersionControl.Provider.Submit", "Start a task that submits the assets to version control." },
{ "VersionControl.Provider.SubmitIsValid", "Returns true if submitting the assets is a valid operation." },
{ "VersionControl.Provider.UnlockIsValid", "Returns true if locking the assets is a valid operation." },
{ "VersionControl.Provider.UpdateSettings", "Start a task that sends the version control settings to the version control system." },
{ "VersionControl.RevertMode", "Defines the behaviour of the version control revert methods." },
{ "VersionControl.Task", "A UnityEditor.VersionControl.Task is created almost everytime UnityEditor.VersionControl.Provider is ask to perform an action." },
{ "VersionControl.Task-assetList", "The result of some types of tasks." },
{ "VersionControl.Task-changeSets", "List of changesets returned by some tasks." },
{ "VersionControl.Task-description", "A short description of the current task." },
{ "VersionControl.Task-messages", "May contain messages from the version control plugins." },
{ "VersionControl.Task-progressPct", "Progress of current task in precent." },
{ "VersionControl.Task-resultCode", "Some task return result codes, these are stored here." },
{ "VersionControl.Task-secondsSpent", "Total time spent in task since the task was started." },
{ "VersionControl.Task-success", "Get whether or not the task was completed succesfully." },
{ "VersionControl.Task-text", "Will contain the result of the Provider.ChangeSetDescription task." },
{ "VersionControl.Task.SetCompletionAction", "Upon completion of a task a completion task will be performed if it is set." },
{ "VersionControl.Task.Wait", "A blocking wait for the task to complete." },
{ "ViewTool", "Enum for Tools.viewTool." },
{ "ViewTool.FPS", "The FPS tool is selected." },
{ "ViewTool.None", "View tool is not selected." },
{ "ViewTool.Orbit", "The orbit tool is selected." },
{ "ViewTool.Pan", "The pan tool is selected." },
{ "ViewTool.Zoom", "The zoom tool is selected." },
{ "WaitForEndOfFrame", "Waits until the end of the frame after all cameras and GUI is rendered, just before displaying the frame on screen." },
{ "WaitForFixedUpdate", "Waits until next fixed frame rate update function." },
{ "WaitForSeconds", "Suspends the coroutine execution for the given amount of seconds." },
{ "WaitForSeconds-ctor", "Creates a yield instruction to wait for a given number of seconds." },
{ "WebCamDevice", "A structure describing the webcam device." },
{ "WebCamDevice-isFrontFacing", "True if camera faces the same direction a screen does, false otherwise." },
{ "WebCamDevice-name", "A human-readable name of the device. Varies across different systems." },
{ "WebCamTexture", "WebCam Textures are textures onto which the live video input is rendered." },
{ "WebCamTexture-ctor", "Create a WebCamTexture." },
{ "WebCamTexture-deviceName", "Set this to specify the name of the device to use." },
{ "WebCamTexture-devices", "Return a list of available devices." },
{ "WebCamTexture-didUpdateThisFrame", "Did the video buffer update this frame?" },
{ "WebCamTexture-isPlaying", "Returns if the camera is currently playing." },
{ "WebCamTexture-isReadable", "Returns if the WebCamTexture is non-readable. (iOS only)." },
{ "WebCamTexture-requestedFPS", "Set the requested frame rate of the camera device (in frames per second)." },
{ "WebCamTexture-requestedHeight", "Set the requested height of the camera device." },
{ "WebCamTexture-requestedWidth", "Set the requested width of the camera device." },
{ "WebCamTexture-videoRotationAngle", "Returns an clockwise angle, which can be used to rotate a polygon so camera contents are shown in correct orientation." },
{ "WebCamTexture-videoVerticallyMirrored", "Returns if the texture image is vertically flipped." },
{ "WebCamTexture.GetPixel", "Returns pixel color at coordinates (x, y)." },
{ "WebCamTexture.GetPixels", "Get a block of pixel colors." },
{ "WebCamTexture.GetPixels32", "Returns the pixels data in raw format." },
{ "WebCamTexture.MarkNonReadable", "Marks WebCamTexture as unreadable (no GetPixel* functions will be available (iOS only))." },
{ "WebCamTexture.Pause", "Pauses the camera." },
{ "WebCamTexture.Play", "Starts the camera." },
{ "WebCamTexture.Stop", "Stops the camera." },
{ "WheelCollider", "A special collider for vehicle wheels." },
{ "WheelCollider-brakeTorque", "Brake torque. Must be positive." },
{ "WheelCollider-center", "The center of the wheel, measured in the object's local space." },
{ "WheelCollider-forwardFriction", "Properties of tire friction in the direction the wheel is pointing in." },
{ "WheelCollider-isGrounded", "Indicates whether the wheel currently collides with something (Read Only)." },
{ "WheelCollider-mass", "The mass of the wheel. Must be larger than zero." },
{ "WheelCollider-motorTorque", "Motor torque on the wheel axle. Positive or negative depending on direction." },
{ "WheelCollider-radius", "The radius of the wheel, measured in local space." },
{ "WheelCollider-rpm", "Current wheel axle rotation speed, in rotations per minute (Read Only)." },
{ "WheelCollider-sidewaysFriction", "Properties of tire friction in the sideways direction." },
{ "WheelCollider-steerAngle", "Steering angle in degrees, always around the local y-axis." },
{ "WheelCollider-suspensionDistance", "Maximum extension distance of wheel suspension, measured in local space." },
{ "WheelCollider-suspensionSpring", "The parameters of wheel's suspension. The suspension attempts to reach a target position." },
{ "WheelCollider.GetGroundHit", "Gets ground collision data for the wheel." },
{ "WheelFrictionCurve", "WheelFrictionCurve is used by the WheelCollider to describe friction properties of the wheel tire." },
{ "WheelFrictionCurve-asymptoteSlip", "Asymptote point slip (default 2)." },
{ "WheelFrictionCurve-asymptoteValue", "Force at the asymptote slip (default 10000)." },
{ "WheelFrictionCurve-extremumSlip", "Extremum point slip (default 1)." },
{ "WheelFrictionCurve-extremumValue", "Force at the extremum slip (default 20000)." },
{ "WheelFrictionCurve-stiffness", "Multiplier for the extremumValue and asymptoteValue values (default 1)." },
{ "WheelHit", "Contact information for the wheel, reported by WheelCollider." },
{ "WheelHit-collider", "The other Collider the wheel is hitting." },
{ "WheelHit-force", "The magnitude of the force being applied for the contact." },
{ "WheelHit-forwardDir", "The direction the wheel is pointing in." },
{ "WheelHit-forwardSlip", "Tire slip in the rolling direction. Acceleration slip is negative, braking slip is positive." },
{ "WheelHit-normal", "The normal at the point of contact." },
{ "WheelHit-point", "The point of contact between the wheel and the ground." },
{ "WheelHit-sidewaysDir", "The sideways direction of the wheel." },
{ "WheelHit-sidewaysSlip", "Tire slip in the sideways direction." },
{ "WheelJoint2D", "The wheel joint allows the simulation of wheels by providing a constraining suspension motion with an optional motor." },
{ "WheelJoint2D-jointSpeed", "The current joint speed." },
{ "WheelJoint2D-jointTranslation", "The current joint translation." },
{ "WheelJoint2D-motor", "Parameters for a motor force that is applied automatically to the Rigibody2D along the line." },
{ "WheelJoint2D-suspension", "Set the joint suspension configuration." },
{ "WheelJoint2D-useMotor", "Should a motor force be applied automatically to the Rigidbody2D?" },
{ "WheelJoint2D.GetMotorTorque", "Gets the motor torque of the joint given the specified timestep." },
{ "Windows.Crypto", "Class representing crypotgraphy algorithms." },
{ "Windows.Crypto.ComputeMD5Hash", "Computes MD5 hash value for the specified byte array." },
{ "Windows.Crypto.ComputeSHA1Hash", "Computes SHA1 hash value for the specified byte array." },
{ "Windows.Directory", "Exposes static methods for directory operations." },
{ "Windows.Directory-localFolder", "Returns a path to local folder." },
{ "Windows.Directory-roamingFolder", "Returns a path to roaming folder." },
{ "Windows.Directory-temporaryFolder", "Returns a path to temporary folder." },
{ "Windows.Directory.CreateDirectory", "Creates directory in the specified path." },
{ "Windows.Directory.Delete", "Deletes a directory from a specified path." },
{ "Windows.Directory.Exists", "Determines whether the given path refers to an existing directory." },
{ "Windows.File", "Provides static methods for file operations." },
{ "Windows.File.Delete", "Deletes the specified file." },
{ "Windows.File.Exists", "Determines whether the specified file exists." },
{ "Windows.File.ReadAllBytes", "Opens a binary file, reads the contents of the file into a byte array, and then closes the file." },
{ "Windows.File.WriteAllBytes", "Creates a new file, writes the specified byte array to the file, and then closes the file. If the target file already exists, it is overwritten." },
{ "Windows.LicenseInformation-isOnAppTrial", "Checks whether the application is installed in trial mode." },
{ "Windows.LicenseInformation.PurchaseApp", "Attempts to purchase the app if it is in installed in trial mode. This API is supported only on Windows Phone 8 and Windows Store Apps." },
{ "WindowsPhone.Media", "Media class represents Windows Phone background media player." },
{ "WindowsPhone.Media-mediaPlayerState", "Gets the current media playback state, Media.MediaState." },
{ "WindowsPhone.Media.MediaState", "MediaState enumeration specifies all three possible values of media playback state: stopped, playing and paused." },
{ "WindowsPhone.Media.MediaState.Paused", "Media playback is paused." },
{ "WindowsPhone.Media.MediaState.Playing", "Media is currently playing." },
{ "WindowsPhone.Media.MediaState.Stopped", "Media playback is stopped." },
{ "WrapMode", "Determines how time is treated outside of the keyframed range of an AnimationClip or AnimationCurve." },
{ "WrapMode.ClampForever", "Plays back the animation. When it reaches the end, it will keep playing the last frame and never stop playing." },
{ "WrapMode.Default", "Reads the default repeat mode set higher up." },
{ "WrapMode.Loop", "When time reaches the end of the animation clip, time will continue at the beginning." },
{ "WrapMode.Once", "When time reaches the end of the animation clip, the clip will automatically stop playing and time will be reset to beginning of the clip." },
{ "WrapMode.PingPong", "When time reaches the end of the animation clip, time will ping pong back between beginning and end." },
{ "WSA.AppCallbackItem", "Delegate that can be invoked on specific thread." },
{ "WSA.Application", "Provides essential methods related to Window Store application." },
{ "WSA.Application-arguments", "Arguments passed to application." },
{ "WSA.Application-windowActivated", "Fired when application window is activated." },
{ "WSA.Application-windowSizeChanged", "Fired when window size changes." },
{ "WSA.Application.InvokeOnAppThread", "Executes callback item on application thread." },
{ "WSA.Application.InvokeOnUIThread", "Executes callback item on UI thread." },
{ "WSA.Application.RunningOnAppThread", "Returns true if you're running on application thread." },
{ "WSA.Application.RunningOnUIThread", "Returns true if you're running on UI thread." },
{ "WSA.Application.TryInvokeOnAppThread", "Tries to execute callback item on application thread." },
{ "WSA.Application.TryInvokeOnUIThread", "Tries to execute callback item on UI thread." },
{ "WSA.Cursor.SetCustomCursor", "Set system cursor to a custom one." },
{ "WSA.SecondaryTileData", "Defines the default look of secondary tile." },
{ "WSA.SecondaryTileData-arguments", "Arguments to be passed for application when secondary tile is activated." },
{ "WSA.SecondaryTileData-backgroundColor", "Defines background color for secondary tile." },
{ "WSA.SecondaryTileData-backgroundColorSet", "Defines, whether backgroundColor should be used." },
{ "WSA.SecondaryTileData-ctor", "Constructor for SecondaryTileData, sets default values for all members." },
{ "WSA.SecondaryTileData-displayName", "Display name for secondary tile." },
{ "WSA.SecondaryTileData-foregroundText", "Defines the style for foreground text on a secondary tile." },
{ "WSA.SecondaryTileData-lockScreenBadgeLogo", "Uri to logo, shown for secondary tile on lock screen." },
{ "WSA.SecondaryTileData-lockScreenDisplayBadgeAndTileText", "Whether to show secondary tile on lock screen." },
{ "WSA.SecondaryTileData-phoneticName", "Phonetic name for secondary tile." },
{ "WSA.SecondaryTileData-roamingEnabled", "Defines whether secondary tile is copied to another device when application is installed by the same users account." },
{ "WSA.SecondaryTileData-showNameOnSquare150x150Logo", "Defines whether the displayName should be shown on a medium secondary tile." },
{ "WSA.SecondaryTileData-showNameOnSquare310x310Logo", "Defines whether the displayName should be shown on a large secondary tile." },
{ "WSA.SecondaryTileData-showNameOnWide310x150Logo", "Defines whether the displayName should be shown on a wide secondary tile." },
{ "WSA.SecondaryTileData-square150x150Logo", "Uri to the logo for medium size tile." },
{ "WSA.SecondaryTileData-square30x30Logo", "Uri to the logo shown on tile" },
{ "WSA.SecondaryTileData-square310x310Logo", "Uri to the logo for large size tile." },
{ "WSA.SecondaryTileData-square70x70Logo", "Uri to the logo for small size tile." },
{ "WSA.SecondaryTileData-tileId", "Unique identifier within application for a secondary tile." },
{ "WSA.SecondaryTileData-wide310x150Logo", "Uri to the logo for wide tile." },
{ "WSA.Tile", "Represents tile on Windows start screen" },
{ "WSA.Tile-exists", "Whether secondary tile is pinned to start screen." },
{ "WSA.Tile-hasUserConsent", "Whether secondary tile was approved (pinned to start screen) or rejected by user." },
{ "WSA.Tile-id", "A unique string, identifying secondary tile" },
{ "WSA.Tile-main", "Returns applications main tile" },
{ "WSA.Tile.CreateOrUpdateSecondary", "Creates new or updates existing secondary tile." },
{ "WSA.Tile.Delete", "Show a request to unpin secondary tile from start screen." },
{ "WSA.Tile.DeleteSecondary", "Show a request to unpin secondary tile from start screen." },
{ "WSA.Tile.Exists", "Whether secondary tile is pinned to start screen." },
{ "WSA.Tile.GetSecondaries", "Gets all secondary tiles." },
{ "WSA.Tile.GetSecondary", "Returns the secondary tile, identified by tile id." },
{ "WSA.Tile.GetTemplate", "Get template XML for tile notification." },
{ "WSA.Tile.PeriodicBadgeUpdate", "Starts periodic update of a badge on a tile." },
{ "WSA.Tile.PeriodicUpdate", "Starts periodic update of a tile." },
{ "WSA.Tile.RemoveBadge", "Remove badge from tile." },
{ "WSA.Tile.StopPeriodicBadgeUpdate", "Stops previously started periodic update of a tile." },
{ "WSA.Tile.StopPeriodicUpdate", "Stops previously started periodic update of a tile." },
{ "WSA.Tile.Update", "Send a notification for tile (update tiles look)." },
{ "WSA.Tile.UpdateBadgeImage", "Sets or updates badge on a tile to an image." },
{ "WSA.Tile.UpdateBadgeNumber", "Set or update a badge on a tile to a number." },
{ "WSA.TileForegroundText", "Style for foreground text on a secondary tile." },
{ "WSA.TileTemplate", "Templates for various tile styles." },
{ "WSA.Toast", "Represents a toast notification in Windows Store Apps." },
{ "WSA.Toast-activated", "/true/ if toast was activated by user." },
{ "WSA.Toast-arguments", "Arguments to be passed for application when toast notification is activated." },
{ "WSA.Toast-dismissed", "/true/ if toast notification was dismissed (for any reason)." },
{ "WSA.Toast-dismissedByUser", "/true/ if toast notification was explicitly dismissed by user." },
{ "WSA.Toast.Create", "Create toast notification." },
{ "WSA.Toast.GetTemplate", "Get template XML for toast notification." },
{ "WSA.Toast.Hide", "Hide displayed toast notification." },
{ "WSA.Toast.Show", "Show toast notification." },
{ "WSA.ToastTemplate", "Templates for various toast styles." },
{ "WSA.WindowActivated", "This event occurs when window completes activation or deactivation, it also fires up when you snap and unsnap the application." },
{ "WSA.WindowActivationState", "Specifies the set of reasons that a windowActivated event was raised." },
{ "WSA.WindowActivationState.CodeActivated", "The window was activated." },
{ "WSA.WindowActivationState.Deactivated", "The window was deactivated." },
{ "WSA.WindowActivationState.PointerActivated", "The window was activated by pointer interaction." },
{ "WSA.WindowSizeChanged", "This event occurs when window rendering size changes." },
{ "WWW", "Simple access to web pages." },
{ "WWW-assetBundle", "Streams an AssetBundle that can contain any kind of asset from the project folder." },
{ "WWW-audioClip", "Returns a AudioClip generated from the downloaded data (Read Only)." },
{ "WWW-bytes", "Returns the contents of the fetched web page as a byte array (Read Only)." },
{ "WWW-bytesDownloaded", "The number of bytes downloaded by this WWW query (read only)." },
{ "WWW-ctor", "Creates a WWW request with the given URL." },
{ "WWW-error", "Returns an error message if there was an error during the download (Read Only)." },
{ "WWW-isDone", "Is the download already finished? (Read Only)" },
{ "WWW-movie", "Returns a MovieTexture generated from the downloaded data (Read Only)." },
{ "WWW-progress", "How far has the download progressed (Read Only)." },
{ "WWW-text", "Returns the contents of the fetched web page as a string (Read Only)." },
{ "WWW-texture", "Returns a Texture2D generated from the downloaded data (Read Only)." },
{ "WWW-textureNonReadable", "Returns a non-readable Texture2D generated from the downloaded data (Read Only)." },
{ "WWW-threadPriority", "Priority of AssetBundle decompression thread." },
{ "WWW-uploadProgress", "How far has the upload progressed (Read Only)." },
{ "WWW-url", "The URL of this WWW request (Read Only)." },
{ "WWW.EscapeURL", "Escapes characters in a string to ensure they are URL-friendly." },
{ "WWW.GetAudioClip", "Returns an AudioClip generated from the downloaded data (Read Only)." },
{ "WWW.LoadFromCacheOrDownload", "Loads an AssetBundle with the specified version number from the cache. If the AssetBundle is not currently cached, it will automatically be downloaded and stored in the cache for future retrieval from local storage." },
{ "WWW.LoadImageIntoTexture", "Replaces the contents of an existing Texture2D with an image from the downloaded data." },
{ "WWW.LoadUnityWeb", "Loads the new web player data file." },
{ "WWW.UnEscapeURL", "Converts URL-friendly escape sequences back to normal text." },
{ "WWWForm", "Helper class to generate form data to post to web servers using the WWW class." },
{ "WWWForm-ctor", "Creates an empty WWWForm object." },
{ "WWWForm-data", "(Read Only) The raw data to pass as the POST request body when sending the form." },
{ "WWWForm-headers", "(Read Only) Returns the correct request headers for posting the form using the WWW class." },
{ "WWWForm.AddBinaryData", "Add binary data to the form." },
{ "WWWForm.AddField", "Add a simple field to the form." },
{ "XboxBuildSubtarget", "Target Xbox build type." },
{ "XboxBuildSubtarget.Debug", "Debug player (for building with source code)." },
{ "XboxBuildSubtarget.Development", "Development player." },
{ "XboxBuildSubtarget.Master", "Master player (submission-proof)." },
{ "XboxOneRunMethod", "Select Xbox One Run Method." },
{ "XboxOneRunMethod.Pull", "Run with project on local disk." },
{ "XboxOneRunMethod.Push", "Run with project on Xbox One disk." },
{ "XboxRunMethod", "Xbox 360 run method." },
{ "XboxRunMethod.DiscEmuAccurate", "Disc emulation (Accurate)." },
{ "XboxRunMethod.DiscEmuFast", "Disc emulation (Fast)." },
{ "XboxRunMethod.HDD", "Copy to hard drive." },
{ "YieldInstruction", "Base class for all yield instructions." },
#endif
};
}

}
